TCP Reliability — ack, retransmission, RTO, fast recovery

import heapq

NSEG       = 10      # মোট segment (প্রতিটা 1 MSS ধরে)
WINDOW     = 5       # sender window
ONE_WAY    = 0.050   # 50 ms একমুখী → RTT 100 ms
RTO0       = 0.500   # initial timeout
DROP_FIRST = {2}     # প্রথম পাঠে হারাবে এই segment-গুলো
REORDER    = {4: 0.030}   # extra delay (sec) — reorder demo

def run(fast_retx):
    drop = set(DROP_FIRST)
    events = []                                  # (time, kind, val)
    def tx(seq, now, tag=""):
        if seq in drop:
            drop.discard(seq)
            print(f"{now:7.3f}  seg-{seq} পাঠানো হলো{tag} … ✗ পথে হারাল")
            return
        heapq.heappush(events, (now + ONE_WAY + REORDER.get(seq, 0),
                                "seg", seq))
        print(f"{now:7.3f}  seg-{seq} পাঠানো হলো{tag}")

    print(f"\n=== mode: fast retransmit {'চালু' if fast_retx else 'বন্ধ'} ===")
    expected, ooo = 1, set()                     # receiver side
    base, nxt = 1, 1                             # sender pointers
    dup, rto_val, rto_dl = 0, RTO0, RTO0
    finish = None
    for s in range(1, min(WINDOW, NSEG) + 1):    # initial window fill
        tx(s, 0.0)

    while finish is None:
        head = events[0][0] if events else float("inf")
        if rto_dl is not None and rto_dl <= head:            # RTO আগে?
            print(f"{rto_dl:7.3f}  ⏱ RTO! seg-{base} পুনঃপ্রেরণ")
            tx(base, rto_dl, tag="(timeout)")
            rto_val *= 2                                     # exponential backoff
            rto_dl += rto_val
            continue
        if not events:
            break
        now, kind, val = heapq.heappop(events)
        if kind == "seg":                                    # receiver-এ পৌঁছাল
            if val == expected:
                expected += 1
                while expected in ooo:
                    ooo.discard(expected); expected += 1
                heapq.heappush(events, (now + ONE_WAY, "ack", expected))
                print(f"{now:7.3f}  seg-{val} পৌঁছাল → ACK-{expected}")
            else:
                ooo.add(val)
                heapq.heappush(events, (now + ONE_WAY, "ack", expected))
                print(f"{now:7.3f}  seg-{val} out-of-order "
                      f"(seg-{expected} নেই!) → DUP-ACK-{expected}")
        else:                                                # sender ACK পেল
            if val > base:
                base, dup = val, 0
                rto_val = RTO0; rto_dl = now + rto_val
                while nxt <= NSEG and nxt < base + WINDOW:
                    tx(nxt, now); nxt += 1
                if base > NSEG:
                    finish = now
            else:                                            # duplicate
                dup += 1
                print(f"{now:7.3f}  DUP-ACK-{val} পেল (#{dup})")
                if fast_retx and dup == 3:
                    print(f"{now:7.3f}  ★ FAST RETRANSMIT seg-{base}")
                    tx(base, now, tag="(fast)")
                    dup, rto_dl = 0, now + rto_val
    return finish

t_fast = run(True)
t_slow = run(False)
print("\n=== ফলাফল ===")
print(f"fast retransmit সহ : {t_fast:.3f}s")
print(f"শুধু RTO-তে        : {t_slow:.3f}s")
print(f"জরিমানার পার্থক্য   : +{(t_slow - t_fast)*1000:.0f} ms")

প্রত্যাশিত আকারের ফলাফল:

=== mode: fast retransmit চালু ===
  0.000  seg-1 পাঠানো হলো
  0.000  seg-2 পাঠানো হলো … ✗ পথে হারাল
  ...
  0.085  ★ FAST RETRANSMIT seg-2
  0.330  ACK-11 পেল
=== mode: fast retransmit বন্ধ ===
  0.500  ⏱ RTO! seg-2 পুনঃপ্রেরণ
  ...
  0.850  ACK-11 পেল
=== ফলাফল ===
fast retransmit সহ : 0.330s
শুধু RTO-তে        : 0.850s
জরিমানার পার্থক্য   : +520 ms

নিজে বাড়ান:

1. REORDER বাড়িয়ে এমন অবস্থা বানান যেখানে ৩-dup নিয়ম ভুল fast retransmit trigger করে (spurious) — দেখুন receiver তবু সঠিক stream বানায়, শুধু bandwidth নষ্ট হয়
2. SACK block report যোগ করুন — receiver dup-ACK-র সাথে ooo-set ছাপবে; sender শুধু gap পুনঃপাঠাবে
3. DROP_FIRST-এ পরপর দুই segment যোগ করুন — fast retransmit- এর পরেও দ্বিতীয় loss-এর জন্য আবার ৩-dup জমা দেখুন