ข้อสอบเก่า · Q9

Selective Repeat 6 เฟรม (เฟรม 2 หาย + ACK ของเฟรม 4 หาย)

ข้อวาดรูป 6 คะแนน ที่มีคำสั่งพิเศษว่า "ลำดับเวลาต้องถูกต้อง" — แปลว่าอาจารย์จะไล่ดูตัวเลขเวลาบนรูปทีละจุด ไม่ใช่แค่ดูว่ามีลูกศรครบไหม · หน้านี้ให้ไทม์ไลน์เป็นวินาทีจริงทุกจุด ตั้งแต่ t = 0 ถึง t = 7.5

ระดับกลาง ควรใช้ ~15 นาที 6 คะแนน อ่านคู่กับ บทที่ 11 (ARQ) ท่าเดียวกับ Q8

คำว่า "ลำดับเวลาต้องถูกต้อง" คือเกณฑ์ให้คะแนน

โจทย์ให้ตัวเลขมาครบ (ไป 1 วินาที · กลับ 1 วินาที · Timeout 2.5 วินาที) แปลว่าอาจารย์ตั้งใจให้เขียนเวลากำกับทุกลูกศร · รูปที่มีลูกศรถูกหมดแต่ไม่มีตัวเลขเวลาเลย ได้ประมาณครึ่งเดียว · เป้าหมายของหน้านี้คือทำให้คุณลอกตารางเวลาลงกระดาษได้จากความจำ

โจทย์จริงจากข้อสอบปีที่แล้ว

Q9 (6 คะแนน · 15 นาที)

แสดงการทำงานของ selective repeat 6 frame โดยที่สมมติให้ frame ที่ 2 หาย แต่ frame ที่ 3 ไปถึงโดยสวัสดิภาพ ในขณะที่ ACK ของ frame ที่ 4 หาย กำหนดให้การสื่อสารจากต้นทางไปยังปลายทางอยู่ที่ 1 วินาที (รวม delay ทั้งหมด), เวลาจากปลายทางมาต้นทาง 1 วินาที และ Timeout อยู่ที่ 2.5 วินาที แสดงการสื่อสารที่เกิดขึ้นโดยลำดับเวลาต้องถูกต้อง

คิดยังไง (แนวคิดใน 30 วินาที)

ข้อนี้จริง ๆ แล้วมีแค่ 3 กลไก ที่ต้องแสดงให้เห็นบนกระดาษ:

① เฟรมหาย → ส่งซ้ำเฉพาะตัวนั้น

F2 หาย · แต่ F3, F4, F5, F6 ยังวิ่งต่อไปตามปกติ (นี่คือความหมายของ "F3 ไปถึงโดยสวัสดิภาพ") · เมื่อ timeout ของ F2 ดัง ผู้ส่งส่งซ้ำแค่ F2 ตัวเดียว — ไม่แตะ F3–F6 เลย

② ผู้รับต้องมีบัฟเฟอร์

F3–F6 มาถึงก่อน F2 ⇒ ไม่ตรงลำดับ · ผู้รับเก็บไว้ในบัฟเฟอร์ (ไม่ทิ้งเหมือน Go-Back-N) แต่ยังตอบ ACK ราย ๆ เฟรม · พอ F2 มาเติมครบ จึงส่งขึ้นเลเยอร์บนพร้อมกันทีเดียว

③ ACK หาย = ผู้ส่งเข้าใจผิด

ACK4 หาย ⇒ ผู้ส่งไม่รู้ว่า F4 ถึงหรือยัง จึงส่ง F4 ซ้ำเมื่อ timeout ทั้งที่ปลายทางได้ไปแล้ว · ผู้รับเห็นว่าเป็นเฟรมซ้ำ → ทิ้งข้อมูล แต่ต้องตอบ ACK4 ใหม่

ท่ามาตรฐาน — จำ 4 ตัวเลขนี้ก็ทำได้แล้ว

ผู้ส่งยิงเฟรมถัดไปทุก 1 วินาที · เฟรมถึงปลายทาง = เวลาที่ยิง + 1 · ACK ถึงต้นทาง = เวลาที่ยิง + 2 · timeout ของเฟรมที่ยิงเวลา t ดังที่ t + 2.5 · ทุกเวลาบนรูปคำนวณจากสี่บรรทัดนี้ล้วน ๆ

สูตร/ขั้นตอนที่ต้องใช้

RTT = t_ไป + t_กลับ = 1 + 1 = 2 วินาที โจทย์ให้ "รวม delay ทั้งหมด" มาแล้ว จึงไม่ต้องแยก t_x / t_prop / t_proc อีก

เฟรมยิงที่เวลา t · ถึง B ที่ t + 1 · ACK ถึง A ที่ t + 2 · timeout ดังที่ t + 2.5 เฟรมถัดไปยิงห่างกัน g = 1 วินาที · เมื่อ timeout ดัง เฟรมส่งซ้ำแทรกออกไปทันที แล้วนับ 1 วินาทีต่อจากจุดนั้นสำหรับเฟรมถัดไป

สัญลักษณ์	ความหมาย	ค่าในโจทย์นี้
`d`	เวลาเดินทางเที่ยวเดียว (one-way) รวมทุก delay	1 วินาที (โจทย์ให้)
`RTT`	ไป + กลับ = `2d`	2 วินาที
`TO`	Timeout — นับจากตอนที่ยิงเฟรมนั้นออกไป	2.5 วินาที (โจทย์ให้ · `> RTT` จึงไม่มีการส่งซ้ำที่ไม่จำเป็น)
`g`	ระยะห่างระหว่างการยิงเฟรมติด ๆ กัน (เวลายิงเฟรมขึ้นสาย)	1 วินาที — โจทย์ไม่ได้ให้ ต้องสมมติเองแล้วเขียนกำกับ · เฉลยใช้ค่านี้
`W`	Window size ฝั่งส่ง (และฝั่งรับ)	W = 6 — ต้องอย่างน้อย 6 เพื่อให้ยิงครบ 6 เฟรมโดยไม่ต้องหยุดรอ

โจทย์ไม่ได้ให้ระยะห่างระหว่างเฟรม — ต้องสมมติเอง แล้วเขียนกำกับ

โจทย์ให้แค่ delay ไป-กลับกับ timeout · ถ้าวาดให้เฟรมทั้ง 6 ออกจากต้นทางพร้อมกันหมดที่ t = 0 ลูกศรจะทับกันจนอ่านไม่ออก และ timeout ทั้ง 6 จะดังพร้อมกัน · วิธีที่ปลอดภัยที่สุดคือเขียนบรรทัด "กำหนดให้" ไว้เหนือรูป ว่า "สมมติผู้ส่งยิงเฟรมถัดไปทุก 1 วินาที · W = 6" แล้วทุกตัวเลขที่ตามมาจะมีที่มาที่ไปทั้งหมด · เฉลยของอาจารย์ใช้ 1 วินาที ⇒ ใช้ค่านี้เป็นหลัก

ส่วนขยาย — ถ้าโจทย์ให้ส่งต่อเนื่องแบบ back-to-back (เฟรมออกห่างกัน 0.5 s)

บางตำราสมมติว่า t_x ของเฟรมสั้นกว่านี้ ⇒ ยิงเฟรมถัดไปได้ทุก 0.5 วินาที · ถ้าใช้ค่านี้ ทุกเวลาจะขยับเข้ามาครึ่งหนึ่งของช่วงห่าง:

จุด	g = 1 s (เฉลย)	g = 0.5 s (back-to-back)
F1…F6 ออกที่	0, 1, 2, 3 · F5 = 4.5 · F6 = 5.5	0, 0.5, 1.0, 1.5, 2.0, 2.5
timeout F2 ดังที่	3.5 (1.0 + 2.5)	3.0 (0.5 + 2.5)
timeout F4 ดังที่	5.5 (3.0 + 2.5)	4.0 (1.5 + 2.5)
ปล่อยบัฟเฟอร์ขึ้น App	4.5	4.0
เสร็จที่	7.5 วินาที ✓	6.0 วินาที

ทั้งสองแบบถูกทั้งคู่ ถ้าเขียนบรรทัด "กำหนดให้" กำกับไว้ — แต่เฉลยของอาจารย์ใช้ 1 วินาที ⇒ คำตอบที่ต้องวงกลมคือ 7.5 วินาที · กลไกทุกอย่าง (ส่งซ้ำเฉพาะตัวที่หาย · บัฟเฟอร์ · เฟรมซ้ำถูกทิ้งแต่ยัง ACK) เหมือนกันเป๊ะ เปลี่ยนแค่ตัวเลข

ถ้าอาจารย์ต้องการแบบ "ยิงพร้อมกันทั้ง 6 เฟรมที่ t = 0" จะได้อะไร

ถ้าตีความว่า transmission time ≈ 0 และยิงทั้ง window ออกไปพร้อมกันที่ t = 0 จะได้ไทม์ไลน์ที่สั้นกว่าและง่ายกว่า:

เวลา	เหตุการณ์
0.0	A ยิง F1–F6 พร้อมกัน · ตั้ง timeout ทุกเฟรมที่ 2.5
1.0	B ได้ F1, F3, F4, F5, F6 (F2 หาย) → เก็บ F3–F6 ในบัฟเฟอร์ · ส่ง ACK1, ACK3, ACK4, ACK5, ACK6
2.0	A ได้ ACK1, ACK3, ACK5, ACK6 (ACK4 หาย)
2.5	timeout ของ F2 และ F4 ดังพร้อมกัน → ส่ง F2 ซ้ำ และ F4 ซ้ำ
3.5	B ได้ F2 → ลำดับครบ ส่ง F1–F6 ขึ้นเลเยอร์บน · ได้ F4 ซ้ำ → ทิ้ง แต่ตอบ ACK4 ใหม่ · ส่ง ACK2 และ ACK4
4.5	A ได้ ACK2 และ ACK4 → จบ

คำตอบ: เสร็จที่ 4.5 วินาที · เฟรมบนสาย 8 เฟรม (เท่าเดิม) · เขียนกำกับว่าตีความแบบไหนก็ได้คะแนนทั้งคู่ — สิ่งที่อาจารย์ตรวจคือลำดับเวลาสอดคล้องกับสมมติฐานของตัวเองหรือเปล่า · แบบ 0.5 วินาทีที่ใช้ในหน้านี้อ่านง่ายกว่าและแสดงกลไกได้ครบกว่า เพราะ timeout ไม่ดังพร้อมกันหมด

เฉลยละเอียดทีละขั้น

ขั้นที่ 1 — เขียนบรรทัด "กำหนดให้" ก่อนเสมอ

one-way delay = 1 s · RTT = 2 s · Timeout = 2.5 s (นับจากตอนส่ง) · ส่งเฟรมถัดไปทุก 1 วินาที (g = 1 s) · W = 6 · F2 หาย · ACK4 หาย

ขั้นที่ 2 — คำนวณเวลาของเฟรมทั้ง 6 ก่อนลงมือวาด

เฟรม	A ยิงออกที่	ถึง B ที่	ACK ถึง A ที่	timeout จะดังที่	ผล
F1	0.0	1.0	2.0	2.5	ACK มาก่อน → ยกเลิก timer ✓
F2	1.0	✕ หายกลางทาง	—	3.5	timeout ดัง → ส่งซ้ำ
F3	2.0	3.0	4.0	4.5	ACK มาก่อน ✓
F4	3.0	4.0	✕ ACK4 หาย	5.5	timeout ดัง → ส่งซ้ำ
F2′ (ซ้ำ)	3.5	4.5	5.5 (ACK2)	6.0	ACK มาก่อน ✓ · ลำดับครบที่ 4.5
F5	4.5	5.5	6.5	7.0	ACK มาก่อน ✓
F4′ (ซ้ำ)	5.5	6.5	7.5 (ACK4′)	8.0	B ทิ้งข้อมูลแต่ยัง ACK
F6	5.5	6.5	7.5	8.0	ACK มาก่อน ✓ ← จบที่นี่

ตารางนี้เขียนได้ภายใน 2 นาทีโดยไม่ต้องวาดอะไรเลย — และมันคือโครงของทั้งรูป

ขั้นที่ 3 — ไทม์ไลน์เต็ม (ลอกลงกระดาษได้เลย)

เวลา (s)	เหตุการณ์ที่ฝั่งส่ง (A)	เหตุการณ์ที่ฝั่งรับ (B)	บัฟเฟอร์ฝั่งรับ
0.0	ส่ง `F1` · ตั้ง timer → 2.5	—	ว่าง
1.0	ส่ง `F2` · ตั้ง timer → 3.5 \| ✕ F2 หายกลางทาง	ได้ `F1` ตรงลำดับ → ส่งขึ้น App ทันที · ส่ง `ACK1` (ถึง A ที่ 2.0)	ว่าง
2.0	ได้ `ACK1` ✓ · ส่ง `F3` · ตั้ง timer → 4.5	—	ว่าง
3.0	ส่ง `F4` · ตั้ง timer → 5.5	ได้ `F3` ไม่ตรงลำดับ (ยังขาด F2) → เก็บบัฟเฟอร์ · ส่ง `ACK3` (ถึง A ที่ 4.0)	`{F3}`
3.5	timeout ของ F2 ดัง (`1.0 + 2.5`) → ส่ง `F2′` ซ้ำเฉพาะเฟรมเดียว	—	`{F3}`
4.0	ได้ `ACK3` ✓	ได้ `F4` → เก็บบัฟเฟอร์ · ส่ง `ACK4` \| ✕ ACK4 หายระหว่างทางกลับ	`{F3, F4}`
4.5	ส่ง `F5` · ตั้ง timer → 7.0	ได้ `F2′` → ลำดับครบ! ส่ง F2, F3, F4 ขึ้น App พร้อมกัน · ส่ง `ACK2` (ถึง A ที่ 5.5)	ว่าง (ปล่อยขึ้นไปหมดแล้ว)
5.5	ได้ `ACK2` ✓ · timeout ของ F4 ดัง (`3.0 + 2.5`) → ส่ง `F4′` ซ้ำ · และส่ง `F6`	ได้ `F5` ตรงลำดับ → ขึ้น App · ส่ง `ACK5` (ถึง A ที่ 6.5)	ว่าง
6.5	ได้ `ACK5` ✓	ได้ `F4′` → เฟรมซ้ำ ทิ้งข้อมูล แต่ตอบ `ACK4′` · ได้ `F6` → ขึ้น App · ส่ง `ACK6`	ว่าง
7.5	ได้ `ACK4′` และ `ACK6` ✓ — ครบทุกเฟรม จบการสื่อสาร	—	ว่าง

คำตอบสุดท้ายที่ต้องเขียนใต้รูป การสื่อสารเสร็จสมบูรณ์ที่ t = 7.5 วินาที เฟรมข้อมูลที่ถูกยิงขึ้นสายจริง = 8 เฟรม (ต้นฉบับ 6 + ส่งซ้ำ F2′ และ F4′ อย่างละ 1) · ACK ที่ B ส่ง = 7 ตัว (A1, A3, A4✕, A2, A5, A4′, A6) · เฟรมที่ B ต้องทิ้ง = 1 เฟรม (F4′ ซ้ำ) · B ปล่อยของก้อนใหญ่ (F2, F3, F4) ขึ้น App ที่ t = 4.5 วินาที และครบทั้ง 6 เฟรมที่ t = 6.5 วินาที

ขั้นที่ 4 — ดูรูปเดินทีละวินาที

จุดที่ควรวงกลมไว้บนกระดาษ 3 จุด

t = 3.5 — timeout F2 ดัง (1.0 + 2.5) แล้วส่งซ้ำแค่ F2 ตัวเดียว (นี่คือคำว่า "Selective")
t = 4.5 — F2′ มาถึง ⇒ ปล่อยของจากบัฟเฟอร์ทั้งก้อน F2, F3, F4 ขึ้นเลเยอร์บนพร้อมกัน
t = 6.5 — F4′ ซ้ำมาถึง ⇒ ทิ้งข้อมูล แต่ยัง ACK (เหตุผลเดียวกับ Q8) · ACK4′ ถึง A ที่ 7.5 = จุดจบ

ถ้าโจทย์เปลี่ยนเป็น Go-Back-N จะต่างกันอย่างไร

โจทย์เดิมทุกอย่าง เปลี่ยนแค่โปรโตคอล — ฝั่งรับไม่มีบัฟเฟอร์ จึงทิ้งทุกเฟรมที่ไม่ตรงลำดับ และเมื่อ timeout ดัง ผู้ส่งต้องถอยกลับไปส่งใหม่ตั้งแต่ F2 จนหมด window

เวลา (s)	เหตุการณ์ที่ฝั่งส่ง (A)	เหตุการณ์ที่ฝั่งรับ (B)	บัฟเฟอร์ฝั่งรับ
0.0 / 1.0 / 2.0 / 3.0	ยิง `F1`, `F2`, `F3`, `F4` ห่างกัน 1 s เหมือนเดิม (F5, F6 ยังไม่ทันได้ยิง)	—	ไม่มีบัฟเฟอร์เลย (W_รับ = 1)
1.0	—	ได้ `F1` → ส่งขึ้นเลเยอร์บน · ส่ง `ACK1` (ถึง A ที่ 2.0)	—
2.0	ได้ `ACK1` ✓	✕ F2 หาย — B ไม่เคยเห็นเฟรมนี้	—
3.0 / 4.0	—	ได้ F3 (3.0) และ F4 (4.0) แต่ทิ้งทั้งคู่ เพราะไม่ตรงลำดับ (รอ F2)	—
3.5	timeout F2 ดัง (`1.0 + 2.5`) → Go Back! ส่งใหม่ `F2` ที่ 3.5, `F3` ที่ 4.5, `F4` ที่ 5.5, `F5` ที่ 6.5, `F6` ที่ 7.5	—	—
4.5 / 5.5 / 6.5 / 7.5 / 8.5	—	ได้ `F2…F6` ตามลำดับ → ส่งขึ้นเลเยอร์บนทีละเฟรม · ส่ง `ACK2…ACK6`	—
7.5	—	✕ ACK4 หาย — แต่ไม่มีผลอะไรเลย เพราะ GBN ใช้ ACK สะสม (cumulative) ⇒ `ACK5` ที่มาถึงตอน 8.5 ยืนยัน F4 ให้อัตโนมัติ	—
9.5	ได้ `ACK6` → จบ	—	—

	Selective Repeat	Go-Back-N
เสร็จที่	7.5 วินาที	9.5 วินาที (ช้ากว่า 2.0 s)
เฟรมบนสาย	8 (ส่งซ้ำ 2: F2′, F4′)	9 = 4 ต้นฉบับ + 5 ส่งซ้ำ (F2–F6)
Receive window	N — เก็บ out-of-order ได้	1 — ทิ้งทุกอย่างที่ไม่ตรงลำดับ
ACK4 หายส่งผลไหม	ส่งผล — ต้องส่ง F4′ ซ้ำโดยไม่จำเป็น (และมันคือเหตุที่จบที่ 7.5)	ไม่ส่งผล — ACK สะสมทำให้ ACK5 ครอบคลุม F4 ให้เอง
ปล่อยของขึ้นชั้นบน	F1 ที่ 1.0 · F2–F4 พร้อมกันที่ 4.5 · F5 ที่ 5.5 · F6 ที่ 6.5	ทีละเฟรมที่ 1.0, 4.5, 5.5, 6.5, 7.5, 8.5

ประโยคที่ทำให้คำตอบเหนือกว่าคนอื่น

ถ้ามีเวลาเหลือ เขียนต่อท้ายว่า "สังเกตว่าใน Go-Back-N การหายของ ACK4 ไม่ส่งผลใด ๆ เพราะ ACK เป็นแบบสะสม (cumulative) — ACK5 ที่ตามมายืนยัน F4 ให้อยู่แล้ว ต่างจาก Selective Repeat ที่ ACK เป็นราย ๆ เฟรม การหายของ ACK4 จึงบังคับให้ต้องส่ง F4 ซ้ำ" — ประโยคนี้แสดงว่าเข้าใจความต่างเชิงกลไก ไม่ใช่แค่จำรูป

ลองเปลี่ยนตัวแปรดูเอง

กับดักที่ทำให้เสียคะแนน

กับดัก 1 — วาด F3, F4, F5, F6 ให้ถูกทิ้ง

คำตอบผิดที่พบมากที่สุด: เขียนที่ฝั่ง B ว่า "ทิ้ง F3 เพราะยังไม่ได้ F2" — นั่นคือ Go-Back-N ไม่ใช่ Selective Repeat · โจทย์ยังย้ำมาให้ด้วยว่า "frame ที่ 3 ไปถึงโดยสวัสดิภาพ" ⇒ ต้องเขียนว่า "เก็บไว้ในบัฟเฟอร์" · ถ้าเขียนว่าทิ้ง จะเสียคะแนนหนักเพราะตอบผิดโปรโตคอลทั้งข้อ

กับดัก 2 — ส่งซ้ำ F2 แล้วส่ง F3–F6 ตามไปด้วย

พอ timeout F2 ดังที่ 3.5 หลายคนวาดต่อว่า "ส่ง F2, F3, F4, F5, F6 ใหม่ทั้งชุด" — ผิด นั่นคือ Go-Back-N · Selective = ส่งซ้ำเฉพาะเฟรมที่มีปัญหา ⇒ ที่ 3.5 ส่งแค่ F2′ และที่ 5.5 ส่งแค่ F4′ รวมส่งซ้ำ 2 เฟรม ไม่ใช่ 5

กับดัก 3 — ลืมว่าผู้รับต้องตอบ ACK ให้เฟรมซ้ำด้วย

ที่ t = 6.5 F4′ ซ้ำมาถึง B หลายคนเขียนแค่ "ทิ้ง" แล้วจบ — ไม่ครบ · B ต้องตอบ ACK4′ ใหม่ เพราะ B ไม่มีทางรู้ว่า ACK ตัวเดิมหายไปหรือแค่มาช้า · ถ้าไม่ตอบ A จะ timeout วนไม่จบ ⇒ รูปจะจบไม่ลง และตัวเลข 7.5 วินาทีจะหายไปด้วย

กับดัก 4 — นับ timeout ผิดจุดเริ่ม

timeout นับจากตอนที่ยิงเฟรมนั้นออกไป ไม่ใช่จากตอนที่เฟรมถึงปลายทาง และไม่ใช่จาก t = 0 ของทั้งรูป · timeout ของ F4 = 3.0 + 2.5 = 5.5 ไม่ใช่ 2.5 · คำตอบผิดที่เจอจริงคือวาดเส้นประ timeout ทั้ง 6 เส้นเรียงกันที่ 2.5 วินาทีเท่ากันหมด

กับดัก 5 — ไม่เขียนตัวเลขเวลาเลย

โจทย์เขียนชัดว่า "ลำดับเวลาต้องถูกต้อง" ⇒ รูปที่สวยแต่ไม่มีเลขกำกับพิสูจน์ไม่ได้ว่าลำดับถูก · อย่างน้อยต้องมีขีดสเกลเวลาบนแกน (0, 1, 2, …, 7, 7.5) และเขียนเวลากำกับที่ จุดที่ timeout ดัง กับ จุดที่ ACK มาถึง ทุกครั้ง

เขียนยังไงให้ได้คะแนนเต็ม

✓	ต้องมีในกระดาษ	เขียนว่าอะไร
☐	บรรทัด "กำหนดให้"	one-way 1 s · RTT 2 s · Timeout 2.5 s · ส่งเฟรมถัดไปทุก 1 s · W = 6
☐	แกนเวลา + ขีดสเกล	รางแนวนอน 2 ราง เวลาไหลซ้าย→ขวา เขียน "เวลา (วินาที)" และขีดที่ 1, 2, …, 7, 7.5
☐	ชื่อโหนด	"ผู้ส่ง A" (รางบน) และ "ผู้รับ B" (รางล่าง)
☐	ลูกศร F1–F6 พร้อมเวลาออก	F1=0.0 · F2=1.0 · F3=2.0 · F4=3.0 · F5=4.5 · F6=5.5
☐	กากบาทที่ F2	ตัดเส้นกลางทาง เขียน "✕ F2 หาย"
☐	กากบาทที่ ACK4	ตัดเส้น ACK ขากลับ เขียน "✕ ACK4 หาย"
☐	คำว่า "เก็บบัฟเฟอร์" ที่ฝั่ง B	เขียนกำกับ F3, F4, F5, F6 อย่างน้อยจุดเดียว + ระบุว่ายัง ACK ราย ๆ เฟรม
☐	เส้นประ timeout 2 เส้น	ที่ 3.5 (F2) และ 5.5 (F4) พร้อมเขียนที่มา `1.0+2.5` และ `3.0+2.5`
☐	ลูกศรส่งซ้ำ 2 เส้น	`F2′` ที่ 3.5 · `F4′` ที่ 5.5 (ใช้สี/เส้นต่างจากต้นฉบับจะอ่านง่าย)
☐	จุดปล่อยของขึ้นชั้นบน	ที่ 4.5 เขียนว่า "ลำดับครบ → ส่ง F2, F3, F4 ขึ้นเลเยอร์บนพร้อมกัน"
☐	เฟรมซ้ำถูกทิ้ง	ที่ 6.5 เขียนว่า "F4′ ซ้ำ → ทิ้งข้อมูล แต่ตอบ ACK4′ ใหม่"
☐	สรุปตัวเลขใต้รูป	เสร็จที่ 7.5 s · เฟรมบนสาย 8 · ส่งซ้ำ 2 · B ปล่อยของก้อนใหญ่ที่ 4.5 s

ลำดับการลงกระดาษ (12 นาที)

0:00–1:00 เขียนบรรทัด "กำหนดให้" + ตารางเวลา 6 บรรทัด (ขั้นที่ 2 ข้างบน) — ตารางนี้เองก็ได้คะแนนแล้ว แม้รูปจะยังไม่เสร็จ
1:00–2:00 ลากรางแนวนอน 2 ราง + ขีดสเกลเวลา 0 ถึง 7.5 วินาที (ช่องละ 0.5)
2:00–5:00 ลากลูกศร F1–F6 ทั้ง 6 เส้น พร้อมเขียนเวลาออกกำกับ · กากบาทที่ F2
5:00–7:30 ลากลูกศร ACK กลับทุกตัว · กากบาทที่ ACK4 · เขียน "เก็บบัฟเฟอร์" ที่ฝั่ง B
7:30–9:30 เส้นประ timeout ที่ 3.5 และ 5.5 + ลูกศรส่งซ้ำ F2′ และ F4′
9:30–11:00 เขียนจุดสำคัญ: ปล่อยของที่ 4.5 · F4′ ซ้ำถูกทิ้งที่ 6.5 · ACK4′ ถึงที่ 7.5
11:00–12:00 สรุปตัวเลขใต้รูป + ประโยคเทียบกับ Go-Back-N (ถ้ามีเวลา)

ประโยคปิดที่ควรเขียนใต้รูป (ลอกไปใช้ได้เลย)

"กำหนดให้ผู้ส่งยิงเฟรมถัดไปทุก 1 วินาที · เมื่อ F2 หาย ผู้รับยังได้ F3 และ F4 ตามปกติ แต่เนื่องจากไม่ตรงลำดับจึงเก็บไว้ในบัฟเฟอร์และตอบ ACK เป็นราย ๆ เฟรม เมื่อ timeout ของ F2 ดังที่ t = 1.0 + 2.5 = 3.5 s ผู้ส่งส่งซ้ำเฉพาะ F2 เพียงเฟรมเดียว F2′ ถึงปลายทางที่ 4.5 s ทำให้ลำดับครบและผู้รับส่ง F2, F3, F4 ขึ้นเลเยอร์บนพร้อมกัน · ส่วน ACK4 ที่หายทำให้ผู้ส่งเข้าใจผิดว่า F4 ไม่ถึง จึงส่ง F4 ซ้ำเมื่อ timeout ดังที่ 3.0 + 2.5 = 5.5 s ผู้รับตรวจพบหมายเลขซ้ำจึงทิ้งข้อมูลแต่ยังต้องตอบ ACK4′ ซึ่งมาถึงผู้ส่งที่ 7.5 s พร้อมกับ ACK6 เป็นอันเสร็จสมบูรณ์ · รวมเฟรมข้อมูลบนสาย 8 เฟรม (ส่งซ้ำเพียง 2 เฟรม) ซึ่งถ้าเป็น Go-Back-N จะต้องส่งซ้ำถึง 5 เฟรมและเสร็จที่ 9.5 s"

โจทย์ฝึก 5 ข้อ

ทุกข้อใช้กติกาเดียวกับของจริง: one-way = 1 s ทั้งสองทาง · เฟรมออกห่างกัน 1 วินาที · เมื่อ timeout ดัง เฟรมส่งซ้ำแทรกออกทันทีแล้วนับ 1 วินาทีต่อจากจุดนั้น · window ใหญ่พอเสมอ · ตอบเป็น "ลำดับเหตุการณ์พร้อมเวลา"

ข้อ 1 อุ่นเครื่อง — Selective Repeat 4 เฟรม · Timeout = 2.5 s · F1 หาย (เฟรมอื่นถึงหมด, ACK ไม่หายเลย)
(ก) timeout ของ F1 ดังเมื่อไร (ข) ผู้รับส่งข้อมูลขึ้นเลเยอร์บนตอนไหน (ค) การสื่อสารเสร็จที่กี่วินาที (ง) เฟรมบนสายกี่เฟรม

เฉลยข้อ 1

ขั้นที่ 1 — ตารางเวลาพื้นฐาน (เฟรมออกทุก 1 วินาที · F1′ แทรกที่ 2.5 ทำให้ F4 เลื่อนไปออกที่ 3.5)

เฟรม	ออกที่	ถึง B	ACK ถึง A	timeout
F1	0.0	✕ หาย	—	2.5 (ดัง)
F2	1.0	2.0	3.0	3.5 (ไม่ดัง)
F3	2.0	3.0	4.0	4.5 (ไม่ดัง)
F1′ (ซ้ำ)	2.5	3.5	4.5	5.0 (ไม่ดัง)
F4	3.5	4.5	5.5	6.0 (ไม่ดัง)

ขั้นที่ 2 — บัฟเฟอร์ฝั่งรับ B ได้ F2 ที่ 2.0 และ F3 ที่ 3.0 แต่ยังขาด F1 ⇒ เก็บบัฟเฟอร์ {F2} แล้ว {F2, F3} และตอบ ACK2, ACK3 ตามปกติ

ขั้นที่ 3 — ส่งซ้ำและจุดจบ

เวลา	เหตุการณ์
2.5	timeout F1 ดัง (`0.0 + 2.5`) → ส่ง `F1′` ซ้ำ
3.5	F1′ ถึง B → ลำดับครบ ส่ง F1, F2, F3 ขึ้นเลเยอร์บนพร้อมกัน · ส่ง `ACK1` (ถึง A ที่ 4.5)
4.5	F4 ถึง B → ตรงลำดับแล้ว → ขึ้น App ทันที · ส่ง `ACK4`
5.5	`ACK4` ถึง A → จบ

(ก) 0.0 + 2.5 = 2.5 วินาที · (ข) ก้อนใหญ่ (F1–F3) ที่ 3.5 วินาที · F4 ที่ 4.5 วินาที · (ค) 5.5 วินาที

(ง) 4 เฟรมต้นฉบับ + ส่งซ้ำ F1 อีก 1 = 5 เฟรม · ข้อสังเกต: เฟรมที่หายเป็นเฟรมแรก ทำให้ของทั้งหมดค้างบัฟเฟอร์ยาวที่สุด — เป็นกรณีที่แสดง "ประโยชน์ของบัฟเฟอร์" ได้ชัดที่สุด

ข้อ 2 ง่าย–กลาง — โจทย์เดิมของ Q9 ทุกอย่าง (6 เฟรม, F2 หาย, Timeout 2.5 s) แต่คราวนี้ที่หายคือ ACK ของเฟรมที่ 3 (ไม่ใช่เฟรมที่ 4)
(ก) timeout ตัวไหนดังบ้าง และดังตอนไหน (ข) การสื่อสารเสร็จที่กี่วินาที (ค) ผู้รับปล่อยของขึ้นเลเยอร์บนตอนไหน

เฉลยข้อ 2

ขั้นที่ 1 — ตารางเวลา (โครงเดิมทุกประการ เปลี่ยนแค่ ACK ที่หาย)

เฟรม	ออกที่	ถึง B	ACK ถึง A	timeout ที่	ดังไหม
F1	0.0	1.0	2.0	2.5	ไม่ดัง ✓
F2	1.0	✕ หาย	—	3.5	ดัง
F3	2.0	3.0	✕ ACK3 หาย	4.5	ดัง
F4	3.0	4.0	5.0	5.5	ไม่ดัง ✓
F5	4.5	5.5	6.5	7.0	ไม่ดัง ✓
F6	5.5	6.5	7.5	8.0	ไม่ดัง ✓

ขั้นที่ 2 — ผลของการส่งซ้ำ

เวลา	เหตุการณ์
3.5	timeout F2 → ส่ง `F2′` ซ้ำ (ถึง B ที่ 4.5)
4.5	F2′ ถึง B → ลำดับครบ ปล่อย F2, F3, F4 ขึ้นเลเยอร์บน · ส่ง `ACK2` (ถึง A ที่ 5.5) \| ที่เวลาเดียวกัน timeout F3 ดัง (`2.0 + 2.5`) → ส่ง `F3′` ซ้ำ · และส่ง `F5`
5.5	F3′ ถึง B → เฟรมซ้ำ ทิ้งข้อมูล แต่ตอบ ACK3′ (ถึง A ที่ 6.5) · F5 ถึง B → ขึ้น App ตอบ `ACK5` · A ส่ง `F6`
7.5	`ACK6` ถึง A → จบ

(ก) ดัง 2 ตัว — F2 ที่ 3.5 s (1.0+2.5) และ F3 ที่ 4.5 s (2.0+2.5)

(ข) เสร็จที่ 7.5 วินาที · เฟรมบนสาย = 6 + 2 = 8 เฟรม

(ค) ปล่อยของก้อนใหญ่ที่ 4.5 วินาที เหมือนโจทย์จริงเป๊ะ — เพราะตัวกำหนดจังหวะปล่อยของคือเฟรมที่หาย (F2) ไม่ใช่ ACK ที่หาย · เวลาจบก็เท่ากับของจริง (7.5 s) แต่มาจากคนละเหตุ: ของจริงจบเพราะ ACK4′ / ข้อนี้จบเพราะ ACK6 ของเฟรมสุดท้าย

ข้อ 3 กลาง — โจทย์เดิมของ Q9 ทุกอย่าง แต่ตั้ง Timeout ผิดเป็น 1.5 วินาที
(ก) ทำไมค่านี้ถึงผิด (ข) เฟรมที่ไม่มีปัญหาอะไรเลยจะถูกยิงขึ้นสายกี่ครั้ง (ค) รวมเฟรมบนสายทั้งหมดกี่เฟรม

เฉลยข้อ 3

(ก) RTT = 2 × 1 = 2 วินาที แต่ TO = 1.5 < 2 ⇒ นาฬิกาดังก่อน ACK จะเดินทางกลับมาถึงเสมอ ⇒ ทุกเฟรมถูกส่งซ้ำโดยไม่จำเป็น (เข้าเงื่อนไขเดียวกับ Q8) · เงื่อนไขที่ถูกคือ TO > RTT

(ข) เฟรมที่ไม่มีปัญหา — นาฬิกาดังทุก 1.5 s จนกว่า ACK จะถึงที่ 2.0 s

c = ⌈ RTTTO ⌉ = ⌈ 2.01.5 ⌉ = ⌈1.33⌉ = 2 ครั้ง

ตรวจด้วยมือ: F1 ออก 0.0 → นาฬิกาดัง 1.5 → ส่งซ้ำ → ACK1 ถึง 2.0 → ยกเลิก · ยิงไป 2 ใบ ✓ (F3, F5, F6 เหมือนกันหมด) · ข้อนี้คิดแบบ "แต่ละเฟรมมีนาฬิกาของตัวเอง ส่งซ้ำไม่เบียดคิวของเฟรมถัดไป" เพื่อให้นับจำนวนได้ตรง ๆ

(ค) รวมทั้งหมด — ต้องแยกนับเฟรมที่มีปัญหา

เฟรม	เหตุการณ์	นาฬิกาดังที่	ยิงขึ้นสาย
F1 (ออก 0.0)	ปกติ · ACK ถึง 2.0	1.5	2
F2 (ออก 1.0)	หาย · ส่งซ้ำที่ 2.5 → ถึง 3.5 → ACK2 ถึง A ที่ 4.5	2.5, 4.0	3
F3 (ออก 2.0)	ปกติ · ACK ถึง 4.0	3.5	2
F4 (ออก 3.0)	ACK4 หาย · ส่งซ้ำที่ 4.5 → ถึง 5.5 → ACK4′ ถึง A ที่ 6.5	4.5, 6.0	3
F5 (ออก 4.0)	ปกติ · ACK ถึง 6.0	5.5	2
F6 (ออก 5.0)	ปกติ · ACK ถึง 7.0	6.5	2

รวม = 2 + 3 + 2 + 3 + 2 + 2 = 14 เฟรมบนสายสำหรับข้อมูลจริงเพียง 6 เฟรม ⇒ เสียเปล่า 8/14 ≈ 57%

บทเรียน: การตั้ง Timeout สั้นเกินไปไม่ได้ทำให้เร็วขึ้น (งานยังจบราว 7.0 s ใกล้เคียงเดิม เพราะตัวกำหนดจังหวะคือ ACK ตัวจริง ไม่ใช่นาฬิกา) แต่เปลืองแบนด์วิดท์เกือบสองเท่า · สังเกตว่า c = ⌈RTT/TO⌉ ไม่ขึ้นกับ g เลย จำนวน 14 เฟรมจึงเท่าเดิมไม่ว่าจะยิงห่างกัน 0.5 หรือ 1 วินาที

ข้อ 4 ข้อวาดรูป — โจทย์เดิมของ Q9 ทุกตัวเลข แต่เปลี่ยนโปรโตคอลเป็น Go-Back-N
จงเขียนไทม์ไลน์ว่า (ก) B ทำอะไรกับ F3–F6 (ข) ที่ t = 3.0 A ส่งอะไรบ้างและเวลาใด (ค) เสร็จที่กี่วินาที เฟรมบนสายกี่เฟรม (ง) การหายของ ACK4 ส่งผลอะไรบ้าง

เฉลยข้อ 4

(ก) Go-Back-N มี receive window = 1 ⇒ B ต้องการ F2 แต่ได้ F3 (3.0) และ F4 (4.0) ⇒ ทิ้งทั้งคู่ เพราะไม่ตรงลำดับ · F5 กับ F6 ยังไม่ทันถูกส่งเลย เพราะ timeout ดังที่ 3.5 ก่อน ⇒ A ถอยกลับไปเริ่มที่ F2

(ข) timeout ของ F2 ดังที่ 1.0 + 2.5 = 3.5 ⇒ ถอยกลับไปส่งใหม่ตั้งแต่ F2 จนหมด window

เฟรมที่ส่งใหม่	A ยิงที่	ถึง B ที่	ACK ถึง A ที่
`F2`	3.5	4.5	5.5
`F3`	4.5	5.5	6.5
`F4`	5.5	6.5	✕ ACK4 หาย
`F5`	6.5	7.5	8.5
`F6`	7.5	8.5	9.5

(ค) เสร็จที่ 9.5 วินาที · เฟรมบนสาย = 4 ต้นฉบับ (F1–F4) + 5 ส่งซ้ำ (F2–F6) = 9 เฟรม

(ง) ไม่ส่งผลอะไรเลย — เพราะ Go-Back-N ใช้ ACK แบบสะสม (cumulative) ⇒ ACK5 ที่มาถึง A ที่ 8.5 ยืนยัน F4 ให้โดยอัตโนมัติ timer ของ F4 จึงถูกยกเลิกไปก่อนที่จะดัง · นี่คือประเด็นเปรียบเทียบที่กินคะแนน: SR ต้องเสียเวลาส่ง F4 ซ้ำเพราะ ACK เป็นราย ๆ เฟรม แต่ GBN ไม่ต้อง · ถึงอย่างนั้น GBN ก็ยังช้ากว่า (9.5 vs 7.5) และเปลืองกว่า (9 vs 8 เฟรม) เพราะเสียของไปเปล่า ๆ ตอนที่ทิ้ง F3 กับ F4

ข้อ 5 ยากกว่าของจริง — จงหาสูตรทั่วไปของเวลาที่ใช้ส่ง N เฟรมด้วย Selective Repeat และ Go-Back-N เมื่อ
one-way delay = d · เฟรมออกห่างกัน g · Timeout = TO (โดย TO > 2d) · เฟรมที่ j หายเพียงเฟรมเดียว ไม่มี ACK หาย
แล้วแทนค่า d = 1, g = 1.0, TO = 2.5, N = 6, j = 2 · และอธิบายว่าทำไมผลของ Q9 จริงจึงเป็น 7.5 ไม่ใช่ค่าที่สูตรให้

เฉลยข้อ 5

ขั้นที่ 1 — เวลาที่เฟรมสุดท้ายจบตามปกติ เฟรมที่ N ออกที่ g(N−1) และ ACK กลับถึง A อีก 2d ต่อมา

T_ปกติ = g(N − 1) + 2d

ขั้นที่ 2 — เวลาที่เฟรมที่หายจบ เฟรม j ออกที่ g(j−1) · timeout ดังที่ g(j−1) + TO · ส่งซ้ำแล้วรออีก 2d

T_ซ่อม = g(j − 1) + TO + 2d

ขั้นที่ 3 — Selective Repeat ส่งซ้ำแค่เฟรมเดียว ⇒ เวลาจบคือตัวที่ช้ากว่า

T_SR = max{ g(N − 1) + 2d , g(j − 1) + TO + 2d }

ขั้นที่ 4 — Go-Back-N หลัง timeout ต้องยิงใหม่ N − j + 1 เฟรม (จาก j ถึง N) เรียงห่างกัน g ⇒ ตัวสุดท้ายออกช้ากว่าตัวแรก g(N − j)

T_GBN = g(j − 1) + TO + g(N − j) + 2d

T_GBN − T_SR = g(N − j)(เมื่อเทอมส่งซ้ำเป็นตัวชนะใน max) — ยิ่งเฟรมหายเร็ว ยิ่งเสียเยอะ เพราะต้องส่งใหม่หลายเฟรม

ขั้นที่ 5 — แทนค่า d = 1, g = 1.0, TO = 2.5, N = 6, j = 2

T_ปกติ = 1 × 5 + 2 = 5 + 2 = 7.0 s
T_ซ่อม = 1 × 1 + 2.5 + 2 = 1 + 4.5 = 5.5 s
T_SR = max{7.0 , 5.5} = 7.0 s (คราวนี้เทอม "ปกติ" ชนะ)
T_GBN = 1 + 2.5 + 1 × 4 + 2 = 9.5 s ✓ ตรงกับไทม์ไลน์ GBN ข้างบน
ผลต่าง = 9.5 − 7.0 = 2.5 s (ไม่เท่ากับ g(N−j) = 4.0 เพราะสูตรผลต่างใช้ได้เฉพาะตอนที่เทอม "ซ่อม" ชนะใน max)

ขั้นที่ 6 — ทำไมของจริงได้ 7.5 ไม่ใช่ 7.0

ของจริงมี สองอย่างที่สูตรตั้งต้นไม่ได้คิด:

(1) ACK4 หาย — สูตรตั้งเงื่อนไขว่า "ไม่มี ACK หาย" แต่โจทย์จริงมีเพิ่มมาอีกหนึ่งเหตุการณ์ ⇒ ต้องคิดเทอมเพิ่มแบบเดียวกัน โดยใช้เวลาที่ยิงเฟรมนั้นจริง ๆ (F4 ยิงที่ 3.0):

T_{ACK หาย} = t_{ส่ง F4} + TO + 2d = 3.0 + 2.5 + 2 = 7.5 s

(2) เฟรมส่งซ้ำแทรกคิว — F2′ ออกที่ 3.5 กินช่องส่งไปหนึ่งช่อง ทำให้ F5 เลื่อนไปออกที่ 4.5 และ F6 ที่ 5.5 (ไม่ใช่ 4.0 / 5.0 ตามสูตร) ⇒ เทอม "ปกติ" ของจริงกลายเป็น 5.5 + 2 = 7.5 s เช่นกัน

T_{SR จริง} = max{ 7.5 , 5.5 , 7.5 } = 7.5 s

สรุปเป็นกฎเดียว: ทุกเหตุการณ์ที่ต้อง "รอ timeout" ไม่ว่าจะเป็นเฟรมหายหรือ ACK หาย ล้วนให้เทอม t_ส่ง + TO + 2d เหมือนกัน และเฟรมสุดท้ายให้เทอม t_{ส่งเฟรมสุดท้าย} + 2d · คำตอบคือ max ของทุกเทอม — เขียนกฎนี้ในข้อสอบแล้วแทนค่าให้ดู จะได้คะแนนเต็มแน่นอน

เช็คความเข้าใจ

ใน Q9 ที่ t = 3.5 เมื่อ timeout ของ F2 ดัง ผู้ส่งต้องส่งอะไรออกไป

Selective Repeat แปลว่า เลือกส่งเฉพาะตัวที่มีปัญหา ⇒ ที่ 3.5 ส่งแค่ F2′ · ส่วน F4′ ส่งซ้ำทีหลังที่ t = 5.5 เมื่อ timeout ของมันเองดัง (3.0 + 2.5) ไม่ใช่พร้อมกัน · ถ้าตอบข้อแรกนั่นคือ Go-Back-N ซึ่งจะทำให้เสร็จที่ 9.5 s แทนที่จะเป็น 7.5 s

ที่ t = 3.0 ผู้รับได้เฟรม F3 ทั้งที่ยังไม่ได้ F2 · ผู้รับต้องทำอย่างไร

Selective Repeat มี receive window = N ⇒ เก็บเฟรมที่มาก่อนเวลาไว้ในบัฟเฟอร์ รอเฟรมที่ขาดมาเติม แล้วค่อยส่งขึ้นไปพร้อมกันตามลำดับ (เกิดขึ้นที่ t = 4.5) · และยังต้องตอบ ACK3 เพราะ SR ตอบรับเป็นราย ๆ เฟรม · ข้อแรกสองข้อคือพฤติกรรมของ Go-Back-N ส่วนข้อสุดท้ายผิดเพราะจะทำให้เลเยอร์บนได้ข้อมูลผิดลำดับ

ถ้าโจทย์เปลี่ยนเป็น Go-Back-N การที่ ACK4 หาย จะส่งผลอย่างไร

Go-Back-N ใช้ cumulative ACK ⇒ ACK5 (ถึง A ที่ 8.5 s) หมายความว่า "ได้ครบถึงเฟรมที่ 5 แล้ว" ซึ่งครอบคลุม F4 ไปด้วย timer ของ F4 จึงถูกยกเลิกก่อนดัง · ต่างจาก Selective Repeat ที่ ACK เป็นราย ๆ เฟรม ทำให้ต้องส่ง F4 ซ้ำจริง ๆ · นี่คือข้อดีข้อเดียวของ GBN ในโจทย์นี้ — แต่โดยรวม GBN ยังช้ากว่า (9.5 vs 7.5 s) และเปลืองกว่า (9 vs 8 เฟรม)

เก็บก่อนออกจากข้อนี้

สี่บรรทัดที่ต้องท่อง: ยิงเฟรมถัดไปทุก 1 วินาที · ถึง B ที่ +1 · ACK ถึง A ที่ +2 · timeout ที่ t_ส่ง + 2.5
timeout ที่ดังจริงมี 2 ตัวเท่านั้น: F2 ที่ 3.5 (1.0+2.5) และ F4 ที่ 5.5 (3.0+2.5) — ที่เหลือ ACK มาถึงก่อนหมด
สามจุดสำคัญบนรูป: 3.5 ส่งซ้ำ F2 ตัวเดียว · 4.5 ปล่อยบัฟเฟอร์ F2, F3, F4 ขึ้นชั้นบน · 6.5 F4′ ซ้ำถูกทิ้งแต่ยัง ACK
คำตอบสรุป: เสร็จที่ 7.5 s · เฟรมบนสาย 8 · ACK ที่ B ส่ง 7 · ทิ้ง 1 เฟรม
เทียบ GBN: 9.5 s · 9 เฟรม · ทิ้ง F3, F4 ไปเปล่า ๆ แต่ ACK4 หายไม่มีผล เพราะ ACK สะสม
ห้ามลืม: เขียนบรรทัด "กำหนดให้" ที่ระบุว่าสมมติเฟรมออกห่างกัน 1 วินาที — เพราะโจทย์ไม่ได้ให้มา