###### tags: `無線及寬頻網路`
# HW4: 信賴區間與佇列管理作業
## 一、 題目說明
:::warning
(1)信賴區間實驗，變更信賴區間
請從原本實驗結果，畫出90%的信賴區間圖，請比較與原圖的差異。

(2)信賴區間實驗，變更實驗次數
請將原本的實驗的次數，由30改為300次，一樣畫出95%的信賴區間圖，請比較與原圖的差異。

(3)佇列管理實驗，變更TCP數量
請將原本的佇列管理實驗，TCP的數量由10增為20，請畫出RED與fifo的佇列長度圖。

(4)佇列管理實驗，變更TCP為UDP
請將原本的佇列管理實驗，TCP改為UDP的CBR，CBR設定如下：

set cbr [new Application/Traffic/CBR]

$cbr attach-agent $udp

$cbr set type_ CBR 

$cbr set packet_size_ 1000 #設定傳送封包的大小為1000 byte

$cbr set rate_ 10mb #設定傳送的速率為1Mbps

$cbr set random_ false

請修改TCL與AWK，比較RED與fifo的(1)throughput(2)delay(3)queue length

你發現這個情況，RED有比fifo好嗎？請解釋看看。
:::

---

### 1. 信賴區間實驗，變更信賴區間。
### 請從原本實驗結果，畫出90%的信賴區間圖，請比較與原圖的差異。
:::info
#### 1.執行畫面

* 90% & 95% 的數值比較

* 90% & 95% 的信賴區間比較圖

* 90% & 原圖 的信賴區間比較圖

#### 2-1.原本程式碼(95ci.awk)

BEGIN {FS="\t"}{ln++}{d=$0-t}{s2=s2+d*d} END \
{s=sqrt(s2/(ln-1)) ; print "sample variance: " s " \
Conf. Int. 95%: " t " +/- " 1.96*s/sqrt(ln)}

#### 2-2.修改程式碼(90ci.awk)

BEGIN {FS="\t"}{ln++}{d=$0-t}{s2=s2+d*d} END \
{s=sqrt(s2/(ln-1)) ; print "sample variance: " s " \
Conf. Int. 90%: " t " +/- " 1.645*s/sqrt(ln)}

#### 3.結果說明
從程式碼及圖形比較可以看出兩點
1. 信賴區間的寬度：
90%信賴區間的寬度會比95%信賴區間的寬度窄。

2. 風險和精確度：
降低信賴區間的信心水準（從95%到90%）
意味著更少地包括真實參數值的可能性，但估計也會更精確。
:::

### 2. 信賴區間實驗，變更實驗次數
請將原本的實驗的次數，由30改為300次，一樣畫出95%的信賴區間圖，請比較與原圖的差異。
:::info
#### 1.執行畫面
* 先進行5種速率，每種各300次實驗
* 計算平均值、標準差及信心區間
* 修改txt
* 新實驗95% & 原圖95% 的信賴區間比較圖

#### 2.程式碼(5S-300.pl)

#!/usr/bin/perl

#1.on-off每次增加的速率為100kbps
#2.固定的速率,執行實驗次數為30次,且執行的結果會存到如result100, result200,...等檔案中
#3.若是要再做同樣速率實驗時,請記得先把resultXXX的檔案刪如

for ($i = 100; $i <=500 ; $i=$i+100) {
    for ($j = 1; $j <= 300; $j++) {
	system("ns exp5.tcl $i $j");
	$f1="out$i-$j.tr";
	$f2="result$i";
	system("awk -f 5T.awk $f1 >> $f2");
	print "\n";
    }
    print "\n";
}

#/ $chmod a+x 5s.pl → 增加執行的權限
#/ ./5s.pl

#### 3.結果說明
從圖形比較可以看出兩點
1. 信賴區間的寬度：
同樣是95%的信賴區間，原本的與新實驗相比，隨著樣本數的增加，信賴區間的寬度變窄。這表示對參數的估計會更精確，因為有更多的數據來支持這個估計。

2. 結果的可靠性：
隨著樣本數的增加，估計的可靠性通常會增加，更接近參數的真實值。

:::

### 3. 佇列管理實驗，變更TCP數量
請將原本的佇列管理實驗，TCP的數量由10增為20，請畫出RED與fifo的佇列長度圖。
:::info
#### 1.執行畫面

fifo TCP 10

RED TCP 10


fifo TCP 20

RED TCP 20

#### 2.結果說明
TCP數量由10增加到20，透過圖樣對比
可以發現使用fifo方式的佇列長度有明顯增加，而使用RED方式的佇列長度沒有太大差異。

:::

---

### 4. 佇列管理實驗，變更TCP為UDP
### 請將原本的佇列管理實驗，TCP改為UDP的CBR，CBR設定如下：

set cbr [new Application/Traffic/CBR]

$cbr attach-agent $udp

$cbr set type_ CBR 

$cbr set packet_size_ 1000 #設定傳送封包的大小為1000 byte

$cbr set rate_ 10mb #設定傳送的速率為1Mbps

$cbr set random_ false

### 請修改TCL與AWK，比較RED與fifo的(1)throughput(2)delay(3)queue length
### 你發現這個情況，RED有比fifo好嗎？請解釋看看。

:::info
#### 1.執行畫面
#### (1)throughput
* fifo

| Flow | Throughput |
| ---------- | ---------- |
| flow0 to 1 | 11.72 |
| flow1 to 3 | 0.00 |
| flow2 to 5 | 9.97 |
| flow3 to 7 | 8.95 |
| flow4 to 9 | 0.00 |
| flow5 to 11| 0.00 |
| flow6 to 13| 24.22 |
| flow7 to 15| 0.00 |
| flow8 to 17| 0.00 |
| flow9 to 19| 8.00 |
| r0_20 to r1_21 | 56 |
| 加總 | 62.86 |
| 平均 | 6.286 |

* RED

| Flow | Throughput |
| ---------- | ---------- |
| flow0 to 1 | 5.83 |
| flow1 to 3 | 4.00 |
| flow2 to 5 | 16.80 |
| flow3 to 7 | 5.14 |
| flow4 to 9 | 0.00 |
| flow5 to 11| 15.97 |
| flow6 to 13| 9.04 |
| flow7 to 15| 4.00 |
| flow8 to 17| 0.00 |
| flow9 to 19| 0.00 |
| r0_20 to r1_21 | 56 |
| 加總 | 60.78 |
| 平均 | 6.078 |

#### (2)delay
* fifo
4.882915
* RED
1.588090

#### (3)queue length
* fifo

* RED

#### 2-1.程式碼(measure-throughput.awk)

#這是測量CBR封包平均吞吐量(average throughput)的awk程式

BEGIN {
	init=0;
	i=0;
}
{
   action = $1;
   time = $2;
   from = $3;
   to = $4;
   type = $5;
   pktsize = $6;
   flow_id = $8;
   src = $9;
   dst = $10;
   seq_no = $11;
   packet_id = $12;
  
#   20是r1 21是r2 0-1/2-3...
 	if(action=="r" && from==21 && to==19 && flow_id==9) {
 		pkt_byte_sum[i+1]=pkt_byte_sum[i]+ pktsize;
		
		if(init==0) {
			start_time = time;
			init = 1;
		}
		
		end_time[i] = time;
		i = i+1;
	}
}
END {
	for(j=1 ; j<i ; j++){
		th = pkt_byte_sum[j] / (end_time[j] - start_time)*8/1000;
	}
	printf("%.2f\n", th);
}

#### 2-2.程式碼(measure-delay-UDP.awk)

#這是測量第一條TCP資料流封包端點到端點間延遲時間的awk程式

BEGIN {
#程式初始化，設定一變數以記錄目前最高處理封包的ID。
     highest_packet_id = 0;
}
{
   action = $1;
   time = $2;
   from = $3;
   to = $4;
   type = $5;
   pktsize = $6;
   flow_id = $8;
   src = $9;
   dst = $10;
   seq_no = $11;
   packet_id = $12;

#記錄目前最高的packet ID
   if ( packet_id > highest_packet_id )
	 highest_packet_id = packet_id;

#記錄封包的傳送時間
   if ( start_time[packet_id] == 0)  
	start_time[packet_id] = time;

#記錄第一條UDP(flow_id=0)的接收時間
   if ( flow_id == 0 && action != "d" && type=="cbr") {
      if ( action == "r" ) {
         end_time[packet_id] = time;
      }
   } else {
#把不是flow_id=0的封包或者是flow_id=0但此封包被drop的時間設為-1
      end_time[packet_id] = -1;
   }
}							  
END {
	sum_delay=0;
	no_sum=0;
#當資料列全部讀取完後，開始計算有效封包的端點到端點延遲時間 
    for ( packet_id = 0; packet_id <= highest_packet_id; packet_id++ ) {
       start = start_time[packet_id];
       end = end_time[packet_id];
       packet_duration = end - start;

#只把接收時間大於傳送時間的記錄列出來
       if ( start < end ) {
       	  #printf("%f %f\n", start, packet_duration);
       	  sum_delay+=packet_duration;
       	  no_sum+=1;
       }
   }

#求出平均封包端點到端點延遲的時間   
   printf("average delay: %f sec\n", sum_delay/no_sum);
}

#### 2-3.程式碼(queue-UDP.tcl)

if {$argc !=2} {
	puts "Usage: ns queue.tcl queuetype_ noflows_ "
	puts "Example:ns queue.tcl myfifo 10"
	puts "queuetype_: myfifo or RED"
	exit
}

set par1 [lindex $argv 0]
set par2 [lindex $argv 1]

# 產生一個模擬的物件
set ns [new Simulator]

#開啟一個trace file，用來記錄封包傳送的過程
set nd [open out-$par1-$par2.tr w]
$ns trace-all $nd

#定義一個結束的程序
proc finish {} {
	global ns nd par2 tcp startT
        $ns flush-trace
        close $nd 
              
    	set time [$ns now]
    	set sum_thgpt 0
  
  	#throughput = 收到Ack數 * Packet Size (Bit) / 傳送時間
  	#收到Ack數 = 傳送出Packet數
    #	for {set i 0} {$i < $par2} {incr i} {
    #		set ackno_($i) [$tcp($i) set ack_]
    #		set thgpt($i) [expr $ackno_($i) * 1000.0 * 8.0 / ($time - $startT($i)) ]
    #		#puts $thgpt($i)
    #		set sum_thgpt [expr $sum_thgpt+$thgpt($i)]
    #	}
    #	
    #	set avgthgpt [expr $sum_thgpt/$par2]
    #	puts "average throughput: $avgthgpt (bps)"
    	exit 0
}


for {set i 0} {$i < $par2} {incr i} {
	set src($i) [$ns node]
	set dst($i) [$ns node]
}

#產生兩個路由器
set r1 [$ns node]
set r2 [$ns node]

#把節點和路由器連接起來
for {set i 0} {$i < $par2} {incr i} {
	$ns duplex-link $src($i) $r1 100Mb [expr ($i*10)]ms DropTail
	$ns duplex-link $r2 $dst($i) 100Mb [expr ($i*10)]ms DropTail
}

$ns duplex-link $r1 $r2 56k 10ms $par1

#設定r1到r2之間的Queue Size為50個封包大小
$ns queue-limit $r1 $r2 50

#把佇列長度記錄下來
set q_ [[$ns link $r1 $r2] queue]
set queuechan [open q-$par1-$par2.tr w]
$q_ trace curq_
$q_ attach $queuechan

#for {set i 0} {$i < $par2} {incr i} {
#	set tcp($i) [$ns create-connection TCP/Reno $src($i) TCPSink $dst($i) 0]
#	$tcp($i) set fid_ $i
#}

for {set i 0} {$i < $par2} {incr i} {
  set udp($i) [new Agent/UDP]
  $ns attach-agent $src($i) $udp($i)
  set null($i) [new Agent/Null]
  $ns attach-agent $dst($i) $null($i)
  $ns connect $udp($i) $null($i)
  $udp($i) set fid_ $i
  
  set cbr($i) [new Application/Traffic/CBR]
  $cbr($i) attach-agent $udp($i)
  $cbr($i) set type_ CBR
  $cbr($i) set packet_size_ 1000
  $cbr($i) set rate_ 1mb
  $cbr($i) set random_ false
}


#隨機在0到1秒之間決定資料流開始傳送時間
set rng [new RNG]
$rng seed 1

set RVstart [new RandomVariable/Uniform]
$RVstart set min_ 0
$RVstart set max_ 1
$RVstart use-rng $rng

#決定開始傳送時間
for {set i 0} { $i < $par2 } { incr i } {
	set startT($i) [expr [$RVstart value]]
	#puts "startT($i) $startT($i) sec"
}

#在指定時間,開始傳送資料
#for {set i 0} {$i < $par2} {incr i} {
#	set ftp($i) [$tcp($i) attach-app FTP]
#	$ns at $startT($i) "$ftp($i) start"
#}

for {set i 0} {$i < $par2} {incr i} {
  $ns at $startT($i) "$cbr($i) start"
}

#在第50秒時去呼叫finish來結束模擬
$ns at 50.0 "finish"

#執行模擬
$ns run

#### 3.結果說明
(1)throughput
從圖比較來看，平均吞吐量FIFO有比較多
(2)delay
4.882915:1.588090
fifo的delay比RED高不少
(3)queue length
柱列長度RED(10000-12000)遠比FIFO(50)高

總體來看:
FIFO跟RED在三點算是各有優劣
:::

---