Serverless-এর ভেতরের কাজ — FaaS, Cold Start, আর Firecracker microVM

এই সিমুলেশনটা এই লেসনের hood সেকশনের LayerTrace থেকে পাওয়া COLD_START_MS = 380 (৫+১৫০+২৫+১৫০+৫০) আর WARM_DISPATCH_MS = 4 সংখ্যা দুইটাই সরাসরি ব্যবহার করে — এলোমেলো অনুমান না, আগের সেকশনগুলোর সাথে সামঞ্জস্যপূর্ণ। traffic pattern-টা ইচ্ছাকৃতভাবে বাস্তবসম্মত করে বানানো হয়েছে (একটা repeating cycle-এ ১ মিনিট “burst” + ৯ মিনিট “quiet”) — সম্পূর্ণ uniform random traffic-এ keep-warm window-এর প্রভাব এত স্পষ্টভাবে দেখা যেত না।

#!/usr/bin/env python3
"""
keepwarm_sim.py -- a toy, but honestly-computed, simulation of the
cold-start vs keep-warm tradeoff a real FaaS platform faces.
"""
import random

COLD_START_MS = 380.0   # from this lesson's cold-start LayerTrace total
WARM_DISPATCH_MS = 4.0  # negligible: route + hand off to an already-live sandbox
EXEC_S = 0.05            # assumed handler execution time, illustrative


def generate_request_stream(duration_s, seed):
    """
    Time-varying Poisson-ish process: repeating 10-minute cycles, each
    made of a 1-minute 'burst' (mean inter-arrival 4s) followed by a
    9-minute 'quiet' stretch (mean inter-arrival 180s).
    """
    rng = random.Random(seed)
    times = []
    t = 0.0
    cycle_s = 600.0
    burst_s = 60.0
    while t < duration_s:
        phase = t % cycle_s
        mean_gap = 4.0 if phase < burst_s else 180.0
        gap = rng.expovariate(1.0 / mean_gap)
        t += gap
        if t < duration_s:
            times.append(t)
    return times


def simulate(request_times, keep_warm_s):
    cold = warm = 0
    total_added_ms = 0.0
    session_end = None
    session_start = None
    session_last_activity_end = None
    reserved_s = 0.0

    def close_session():
        nonlocal reserved_s
        if session_start is not None:
            reserved_s += (session_last_activity_end + keep_warm_s) - session_start

    for t in request_times:
        if session_end is not None and t <= session_end:
            warm += 1
            added = WARM_DISPATCH_MS
        else:
            close_session()
            cold += 1
            added = COLD_START_MS
            session_start = t
        total_added_ms += added
        end_t = t + EXEC_S + added / 1000.0
        session_last_activity_end = end_t
        session_end = end_t + keep_warm_s

    close_session()

    n = len(request_times)
    return {
        "n": n, "cold": cold, "warm": warm,
        "cold_rate_pct": 100.0 * cold / n,
        "avg_added_ms": total_added_ms / n,
        "reserved_hours": reserved_s / 3600.0,
    }


if __name__ == "__main__":
    DURATION_S = 2 * 3600
    SEED = 7
    requests = generate_request_stream(DURATION_S, SEED)

    print(f"simulated duration          : {DURATION_S/3600:.1f} hours")
    print(f"total requests generated    : {len(requests)}")
    print(f"COLD_START_MS               : {COLD_START_MS}")
    print(f"WARM_DISPATCH_MS             : {WARM_DISPATCH_MS}")
    print()

    keep_warm_windows_s = [0, 30, 60, 300, 600, 900]
    header = (f"{'keep-warm window':>18} | {'cold':>6} | {'warm':>6} | "
              f"{'cold-rate':>10} | {'avg added lat':>14} | {'reserved (env-hours)':>21}")
    print(header)
    print("-" * len(header))
    rows = []
    for kw in keep_warm_windows_s:
        r = simulate(requests, kw)
        rows.append((kw, r))
        label = f"{kw}s" if kw < 60 else f"{kw//60}min"
        print(f"{label:>18} | {r['cold']:>6} | {r['warm']:>6} | "
              f"{r['cold_rate_pct']:>9.1f}% | {r['avg_added_ms']:>12.1f}ms | "
              f"{r['reserved_hours']:>19.2f}h")

    print()
    base = rows[0][1]
    best = rows[-1][1]
    print("reading the tradeoff (keep_warm=0s vs keep_warm=900s/15min):")
    print(f"  cold-start rate falls from {base['cold_rate_pct']:.1f}% to {best['cold_rate_pct']:.1f}%")
    print(f"  average added latency falls from {base['avg_added_ms']:.1f}ms to {best['avg_added_ms']:.1f}ms")
    print(f"  but idle-reserved environment-hours rise from {base['reserved_hours']:.2f}h "
          f"to {best['reserved_hours']:.2f}h over this {DURATION_S/3600:.1f}h window "
          f"({best['reserved_hours']/max(base['reserved_hours'],1e-9):.1f}x more billable idle time)")

সত্যিই চালিয়ে পাওয়া output (deterministic — seed=7 দিয়ে, হুবহু এটাই আসবে):

simulated duration          : 2.0 hours
total requests generated    : 118
COLD_START_MS               : 380.0
WARM_DISPATCH_MS             : 4.0

  keep-warm window |   cold |   warm |  cold-rate |  avg added lat |  reserved (env-hours)
------------------------------------------------------------------------------------------
                0s |    108 |     10 |      91.5% |        348.1ms |                0.01h
               30s |     27 |     91 |      22.9% |         90.0ms |                0.35h
              1min |     24 |     94 |      20.3% |         80.5ms |                0.56h
              5min |     10 |    108 |       8.5% |         35.9ms |                1.57h
             10min |      3 |    115 |       2.5% |         13.6ms |                1.98h
             15min |      1 |    117 |       0.8% |          7.2ms |                2.18h

reading the tradeoff (keep_warm=0s vs keep_warm=900s/15min):
  cold-start rate falls from 91.5% to 0.8%
  average added latency falls from 348.1ms to 7.2ms
  but idle-reserved environment-hours rise from 0.01h to 2.18h over this 2.0h window (174.8x more billable idle time)

সংখ্যাগুলো নিজেই এই লেসনের কেন্দ্রীয় ট্রেড-অফটা প্রমাণ করে দেয়। keep_warm_s = 0-এ (প্রতিটা invocation-এর পরেই environment সাথে সাথে টিয়ারডাউন) cold-start rate ৯১.৫% — প্রায় প্রতিটা request-ই cold, কারণ এই burst/quiet traffic প্যাটার্নে দুইটা পরপর request-এর মধ্যে গড় ব্যবধান window-এর চেয়ে অনেক বড়। window ১৫ মিনিটে বাড়ালে cold-start rate ০.৮%-এ নেমে আসে (প্রায় প্রতিটা request-ই warm) — কিন্তু environment-hours ২১৮ গুণ (০.০১h → ২.১৮h) বেড়ে যায়, কারণ প্রতিটা invocation-এর পরে environment ১৫ মিনিট ধরে idle-এ “রিজার্ভড” থেকে যাচ্ছে, ব্যবহার হোক বা না হোক। এই idle-reserved সময়টাই বাস্তব cloud provider-দের কাছে সরাসরি খরচ — মেমরি/CPU রিজার্ভেশন কেউ ব্যবহার না করলেও প্ল্যাটফর্মের নিজের হার্ডওয়্যারে জায়গা দখল করে থাকে। এই কারণেই AWS Lambda-র মতো প্ল্যাটফর্ম “Provisioned Concurrency”-র মতো ফিচার আলাদাভাবে মূল্য নির্ধারণ করে — keep-warm একটা বিনামূল্যের সুবিধা না, এটা একটা সচেতন, পরিমাপযোগ্য latency-বনাম-cost সিদ্ধান্ত।