Quorum Replication — primary-backup, NWR, chain

# quorum_probe.py — N=3 cluster: W/R sweep + hinted-handoff outage
import random

def sweep_row(W, R, rounds=300, seed=42):
    rng = random.Random(seed)
    applied = [0] * 3                    # replica -> latest version
    inflight, ackq = [], []
    acked, latencies, stales = 0, [], []
    for t in range(1, rounds + 1):
        v = t                            # ---- write: W-target apply ----
        arrs = [(t + rng.randint(1, 3), v, i)
                for i in rng.sample(range(3), W)]
        inflight += arrs
        ackq.append((max(a for a, _, _ in arrs), v, t))
        done = [e for e in inflight if e[0] <= t]     # ---- pump ----
        inflight = [e for e in inflight if e[0] > t]
        for _, ver, i in done:
            applied[i] = max(applied[i], ver)
        ready = [q for q in ackq if q[0] <= t]
        ackq = [q for q in ackq if q[0] > t]
        for at, ver, st in ready:
            acked = max(acked, ver)
            latencies.append(at - st)
        picks = rng.sample(range(3), R)               # ---- read ----
        lag = max(0, acked - max(applied[i] for i in picks))
        stales.append(lag)
    s = sorted(stales)
    ls = sorted(latencies)
    pct = lambda xs, p: xs[min(int(len(xs) * p), len(xs) - 1)]
    return (100 * sum(1 for x in s if x > 0) / len(s),
            pct(ls, .50), pct(ls, .95))

print(f"{'config':<10}{'stale%':>8}{'w-p50':>6}{'w-p95':>6}   W+R>N?")
for W in (1, 2, 3):
    for R in (1, 2, 3):
        sp, l50, l95 = sweep_row(W, R)
        mark = "হ্যাঁ" if W + R > 3 else "না"
        print(f"W={W},R={R:<4}{sp:>7.1f}%{l50:>6}{l95:>6}   {mark}")

def outage(sloppy, horizon=170):
    """A,C মরে tick 41/61-এ, 101-এ ফেরে; W=2."""
    alive = {"A": True, "B": True, "C": True}
    store = {"A": 0, "B": 0, "C": 0, "D": 0}
    hints, pending = [], []              # D-র জমা / drain-queue
    rejects = offloaded = drained_at = 0
    v = rr = 0
    for t in range(1, horizon + 1):
        if t == 41: alive["C"] = False
        if t == 61: alive["A"] = False
        if t == 101:                     # ফিরল -> drain শুরু
            alive["A"] = alive["C"] = True
            pending = sorted(hints); hints = []
        natural = [n for n in "ABC" if alive[n]]
        ring = natural[:] + (["D"] if sloppy and len(natural) < 2 else [])
        k = rr % len(ring); pref = ring[k:] + ring[:k]; rr += 1
        if len(pref) >= 2:               # W=2 reachable?
            v += 1
            for n in pref[:2]:
                store[n] = max(store[n], v)
                if n == "D":
                    hints.append(v); offloaded += 1
        else:
            rejects += 1
        if t >= 101 and pending:         # প্রতি tick-এ এক hint ঘরে
            store["C"] = max(store["C"], pending.pop(0))
            if not pending:
                drained_at = t
        if sloppy and t % 40 == 0:
            print(f"   tick {t:>3}: pending-hints = "
                  f"{len(hints) + len(pending)}")
    return store, rejects, offloaded, drained_at, v

store, rej, off, dr, v = outage(sloppy=False)
print(f"STRICT : outage rejects = {rej} (down)")
store, rej, off, dr, v = outage(sloppy=True)
print(f"SLOPPY : offloaded-on-D = {off}, drained at tick {dr}")
top = max(store.values())
for n_ in store: store[n_] = top         # anti-entropy pass
assert store["A"] == store["B"] == store["C"] == v
print("OK: drain + anti-entropy -> converged")

প্রত্যাশিত output (seed-fixed):

config      stale% w-p50 w-p95   W+R>N?
W=1,R=1      67.3%     2     3   না
W=1,R=2      30.7%     2     3   না
W=1,R=3       0.0%     2     3   হ্যাঁ
W=2,R=1      21.0%     3     3   না
W=2,R=2       0.0%     3     3   হ্যাঁ
W=2,R=3       0.0%     3     3   হ্যাঁ
W=3,R=1       0.0%     3     3   হ্যাঁ
W=3,R=2       0.0%     3     3   হ্যাঁ
W=3,R=3       0.0%     3     3   হ্যাঁ
STRICT : outage rejects = 40 (down)
   tick  40: pending-hints = 0
   tick  80: pending-hints = 20
   tick 120: pending-hints = 20
   tick 160: pending-hints = 0
SLOPPY : offloaded-on-D = 40, drained at tick 140
OK: drain + anti-entropy -> converged

পড়ার সময়: sweep-এ প্রতিটা হ্যাঁ row একটা theorem-instance; outage-এ hint-curve 61→101 উঠবে, drain-এ নামবে — availability আর healing-ঋণ live।