Failure Models — Crash থেকে Byzantine পর্যন্ত ভাঙার সোপান

লক্ষ্য: একই heartbeat-data, চারটা ভিন্ন T-তে চালিয়ে দেখানো — threshold ছোট করলে সত্যিকারের crash তাড়াতাড়ি ধরা পড়ে, কিন্তু জীবিত-শুধু-ধীর node-ও তত সহজে ভুল-suspect হয়। এই দুই কলামের বিপরীত দিকে চলাই “trade-off”-এর গাণিতিক প্রমাণ, শুধু দাবি না।

# failure_detector_sweep.py — FailureDetector ক্লাস + threshold sweep
ARRIVALS = {
    "A": [10, 21, 29, 41, 49, 61, 71, 79, 91, 101, 109],
    "B": [10, 20, 30, 40, 75, 85, 95, 105],   # GC-pause: gap 40->75 = 35 tick
    "C": [10, 20, 30, 40, 50],                 # প্রকৃত crash, t=50-এর পরে চিরনীরব
}
HORIZON = 110

class FailureDetector:
    """Fixed-threshold heartbeat detector — একটাই knob: T"""
    def __init__(self, T):
        self.T = T
        self.last_hb = {n: 0 for n in ARRIVALS}
        self.suspected = {n: False for n in ARRIVALS}
        self.events = []

    def tick(self, t):
        for node, sched in ARRIVALS.items():
            if t in sched:
                self.last_hb[node] = t
                if self.suspected[node]:
                    self.suspected[node] = False
                    self.events.append((t, node, "CLEAR", 0))
        for node in ARRIVALS:
            if not self.suspected[node] and t - self.last_hb[node] > self.T:
                self.suspected[node] = True
                self.events.append((t, node, "SUSPECT", t - self.last_hb[node]))

    def run(self, horizon=HORIZON):
        for t in range(1, horizon + 1):
            self.tick(t)
        return self.events


print("— threshold sweep: B (জীবিত, ধীর) বনাম C (মৃত) —")
for T in (15, 25, 35, 45):
    fd = FailureDetector(T)
    events = fd.run()
    b_ev = [e for e in events if e[1] == "B"]
    c_ev = [e for e in events if e[1] == "C"]
    fp = any(e[2] == "SUSPECT" for e in b_ev)
    dur = (next(e[0] for e in b_ev if e[2] == "CLEAR") -
           next(e[0] for e in b_ev if e[2] == "SUSPECT")) if fp else 0
    latency = next(e[0] for e in c_ev if e[2] == "SUSPECT") - 50
    assert latency == T + 1, "C সবসময় ঠিক T+1 tick পরে ধরা পড়ে — detector-এর গাণিতিক সীমা"
    print(f"T={T}  B_false_positive={fp}  fp_duration={dur}  C_detect_latency={latency}")

print("OK: T >= 35 (আসল pause-length) হলেই false-positive শূন্য, "
      "কিন্তু detect-latency তখনও T+1 — বিনামূল্যে নয়")

প্রত্যাশিত output (deterministic — হুবহু এটাই আসবে):

— threshold sweep: B (জীবিত, ধীর) বনাম C (মৃত) —
T=15  B_false_positive=True  fp_duration=19  C_detect_latency=16
T=25  B_false_positive=True  fp_duration=9  C_detect_latency=26
T=35  B_false_positive=False  fp_duration=0  C_detect_latency=36
T=45  B_false_positive=False  fp_duration=0  C_detect_latency=46
OK: T >= 35 (আসল pause-length) হলেই false-positive শূন্য, কিন্তু detect-latency তখনও T+1 — বিনামূল্যে নয়

সারণিটা পড়ার মূল কথা: T=15-এ crash ধরা পড়ে ১৬ tick-এ — চমৎকার দ্রুত — কিন্তু B-র মতো জীবিত-ধীর node ১৯ tick ধরে ভুলভাবে “মৃত” তকমা বহন করে। T=35-এ পৌঁছালে (ঠিক B-র pause-length-এর সমান) false-positive উধাও, কিন্তু crash ধরতে এখন ৩৬ tick লাগছে। কোনো T-ই দুটোকেই একসাথে ছোট করতে পারে না — এই একটা সারণিই ভবিষ্যতের leader-election আর distributed-locks লেসনের “failure detector ভুল হলে দুই leader জন্মায়” বাক্যটার সংখ্যাগত ভিত্তি।

নিজে বাড়ান:

1. দ্বিতীয় flaky node D যোগ করুন যার pause 50 tick — T=35 কি তখনও নিরাপদ?
2. Phi-accrual failure detector (Cassandra/Akka-তে ব্যবহৃত) ধারণাটা দেখুন — fixed T-এর বদলে observed heartbeat-distribution থেকে suspicion-score বার করে; কেন সেটা latency না বাড়িয়ে false-positive কমাতে পারে
3. একই node বারবার pause করলে (repeated GC) — single-incident duration-এর বদলে প্রকৃত “rate” বার করুন (কত fraction heartbeat মিস হলো)