Physical Time — NTP, Clock Skew, আর কেন Wall Clock বিশ্বাস করা যায় না

লক্ষ্য: hood/example সেকশনের ঠিক সেই M1/M2 সংখ্যা কোডে চালিয়ে দেখানো যে LWW সত্যিই ভুল write রাখে — আর তার পাশে দেখানো যে monotonic clock ব্যবহার করলে negative-elapsed bug কখনোই ঘটে না।

# clock_skew_lab.py — ClockSkewLab: LWW anomaly + monotonic guard
class Machine:
    def __init__(self, name, offset_ms):
        self.name = name
        self.offset_ms = offset_ms       # সত্যিকারের সময় থেকে কত পিছিয়ে/এগিয়ে

    def clock(self, real_time_ms):
        return real_time_ms + self.offset_ms   # নিজের (সম্ভবত skewed) ঘড়ি

def lww_merge(writes):
    # writes: list of (machine_name, timestamp, value); সবচেয়ে বড় timestamp জেতে
    return max(writes, key=lambda w: w[1])

M1 = Machine("M1", offset_ms=0)       # নিখুঁত
M2 = Machine("M2", offset_ms=-100)    # ১০০ms পিছিয়ে

REAL_A, REAL_B = 1000, 1050           # real time-এ B, A-র ৫০ms পরে লেখা হলো

ts_A = M1.clock(REAL_A)               # 1000
ts_B = M2.clock(REAL_B)               # 950

writes = [("M1", ts_A, "A"), ("M2", ts_B, "B")]
winner = lww_merge(writes)

print(f"write A: machine=M1  real_time={REAL_A}  timestamp={ts_A}")
print(f"write B: machine=M2  real_time={REAL_B}  timestamp={ts_B}   (real-এ ৫০ms পরে!)")
print(f"LWW winner: {winner}")

real_order_winner = "B" if REAL_B > REAL_A else "A"
assert winner[2] == "A"
assert real_order_winner == "B"
print(f"real-time-এ শেষ লেখা ছিল '{real_order_winner}', কিন্তু LWW রাখল "
      f"'{winner[2]}' — {abs(M2.offset_ms)}ms skew-ই একমাত্র কারণ")

# ---------- monotonic guard: negative-elapsed bug কখনো এখানে ঘটবে না ----------
class FakeWallClock:
    """সময়ের মাঝে একবার বড় step (ঘড়ি পেছনে লাফায়) — বাস্তব NTP-correction।"""
    def __init__(self):
        self.t = 0
    def time(self):
        return self.t

class FakeMonotonicClock:
    """একই দৃশ্যে monotonic — শুধু এগোয়, step-এর প্রভাব নেই।"""
    def __init__(self):
        self.t = 0
    def monotonic(self):
        return self.t

wall, mono = FakeWallClock(), FakeMonotonicClock()
wall.t, mono.t = 100, 100
start_wall, start_mono = wall.time(), mono.monotonic()

wall.t = 97          # NTP step: wall clock ৩ একক পিছিয়ে গেল
mono.t = 106          # monotonic শুধু এগোয় — real elapsed যাই হোক

elapsed_wall = wall.time() - start_wall
elapsed_mono = mono.monotonic() - start_mono
print(f"wall-clock দিয়ে মাপা elapsed  = {elapsed_wall}   (ঋণাত্মক! bug)")
print(f"monotonic দিয়ে মাপা elapsed   = {elapsed_mono}   (>= 0, guarantee-সহ)")
assert elapsed_wall < 0
assert elapsed_mono >= 0
print("OK: wall clock negative-elapsed দিল, monotonic দেয়নি — এটাই দুইটার তফাত")

প্রত্যাশিত output — সংখ্যাগুলো hood/example সেকশনের সাথে হুবহু মেলে:

write A: machine=M1  real_time=1000  timestamp=1000
write B: machine=M2  real_time=1050  timestamp=950   (real-এ ৫০ms পরে!)
LWW winner: ('M1', 1000, 'A')
real-time-এ শেষ লেখা ছিল 'B', কিন্তু LWW রাখল 'A' — 100ms skew-ই একমাত্র কারণ
wall-clock দিয়ে মাপা elapsed  = -3   (ঋণাত্মক! bug)
monotonic দিয়ে মাপা elapsed   = 6   (>= 0, guarantee-সহ)
OK: wall clock negative-elapsed দিল, monotonic দেয়নি — এটাই দুইটার তফাত

দুই মুহূর্ত মনে রাখার মতো: প্রথম block-এ 100ms skew-ই একমাত্র কারণ যে সঠিক write হারালো — কোনো network loss, কোনো bug নেই, শুধু ঘড়ি; দ্বিতীয় block-এ একই ভুল-যন্ত্র (wall clock) elapsed-time মাপায় ব্যবহার করলে ঠিক কী ভাঙে তা এক লাইনে দেখা গেল।

নিজে বাড়ান:

1. offset_ms কে parameter করে দেখুন কত বড় skew হলে “৫০ms পরের write” আবার harার order-ই invert করে দেয় — একটা threshold খুঁজুন
2. তিন-machine version বানান যেখানে pairwise skew ভিন্ন — কোন pair সবচেয়ে বিপজ্জনক?
3. lww_merge-এ tie-breaker (timestamp সমান হলে?) যোগ করুন — বাস্তব system-গুলো এখানে machine-id বা random ব্যবহার করে, কেন সেটাও একটা compromise তা লিখুন