cgroups v2 — কে কতটুকু ব্যবহার করতে পারবে, তার নির্ভুল নিয়ন্ত্রণ

এই simulation kernel-এর CFS bandwidth controller-এর মূল যুক্তির একটা সরল, ধারণাগতভাবে সঠিক পুনর্নির্মাণ — বাস্তব kernel কোড C-তে লেখা, আর per-CPU runtime slice, lock-free accounting-এর মতো বাড়তি জটিলতা সামলায়, কিন্তু মূল “প্রতি period-এ তাজা বাজেট, শেষ হলে থ্রটল, আগেরটা carry হয় না” — এই যুক্তিটা ঠিক এইটাই।

"""
cpu.max quota/period throttling simulation — cgroup v2 CFS bandwidth
controller-এর মূল যুক্তির একটা সরল, ধারণাগতভাবে সঠিক পুনর্নির্মাণ।

cpu.max ফাইলের ফরম্যাট: "<quota> <period>" (দুইটাই microsecond-এ)।
প্রতিটা period-এর শুরুতে cgroup একটা তাজা quota বাজেট পায়। সেই
বাজেট period-এর মধ্যে CPU-তে চলার সময়ের বিপরীতে খরচ হয় (idle সময়
খরচ হয় না)। বাজেট শেষ হয়ে গেলে, period শেষ না হওয়া পর্যন্ত cgroup
থ্রটল হয়ে থাকে — ব্যবহৃত না হওয়া বাজেট পরের period-এ carry over
হয় না, প্রতিটা period শূন্য থেকে শুরু।
"""

PERIOD_US = 100_000   # 100ms — cgroup v2-এর ডিফল্ট period
QUOTA_US = 50_000      # 50ms প্রতি period => 0.5 CPU সমতুল্য cap
                        # cpu.max ফাইলে যা লেখা হতো: "50000 100000"

# (arrival_time_us, duration_us) — প্রতিটা burst একটা একটানা CPU-bound
# কাজ যা যত দ্রুত সম্ভব শুরু হতে চায় (arrival-এর পরে, বা আগের burst
# শেষ হওয়ার পরে, যেটা পরে ঘটে)
BURSTS = [
    (0, 80_000),
    (150_000, 30_000),
    (300_000, 120_000),
]


def simulate(period, quota, bursts):
    usage_by_period = {}
    run_events = []       # (start, end, period_index)
    throttle_events = []  # (start, end, duration)
    t = 0

    for arrival, duration in bursts:
        t = max(t, arrival)
        remaining = duration
        while remaining > 0:
            period_index = t // period
            period_start = period_index * period
            period_end = period_start + period
            used = usage_by_period.get(period_index, 0)
            avail = quota - used

            if avail <= 0:
                throttle_start = t
                t = period_end
                throttle_events.append((throttle_start, t, t - throttle_start))
                continue

            run_time = min(avail, remaining, period_end - t)
            run_events.append((t, t + run_time, period_index))
            usage_by_period[period_index] = used + run_time
            t += run_time
            remaining -= run_time

    return run_events, throttle_events, usage_by_period


if __name__ == "__main__":
    print(f'cpu.max = "{QUOTA_US} {PERIOD_US}"  (quota/period, microsecond)')
    print(f"=> প্রতি period-এ {QUOTA_US/1000:.0f}ms CPU বাজেট, cap = {QUOTA_US/PERIOD_US:.2f} CPU\n")

    run_events, throttle_events, usage_by_period = simulate(PERIOD_US, QUOTA_US, BURSTS)

    print("burst অনুরোধ (arrival_us, duration_us):")
    for a, d in BURSTS:
        print(f"  arrival={a:>7}  duration={d:>7}")
    print()

    print("চলমান segment (RUN):")
    for start, end, pidx in run_events:
        print(f"  t=[{start:>7}, {end:>7}]  duration={end-start:>6}us  period#{pidx}")
    print()

    print("থ্রটল হওয়া segment (THROTTLED):")
    total_throttled = 0
    for start, end, dur in throttle_events:
        print(f"  t=[{start:>7}, {end:>7}]  duration={dur:>6}us")
        total_throttled += dur
    print()

    print(f"মোট throttle সংখ্যা (nr_throttled): {len(throttle_events)}")
    print(f"মোট throttled সময় (throttled_usec): {total_throttled}us = {total_throttled/1000:.1f}ms")
    print()

    print("প্রতি period-এ ব্যবহৃত বাজেট (usage_usec / quota_usec):")
    for pidx in sorted(usage_by_period):
        used = usage_by_period[pidx]
        print(f"  period#{pidx} [{pidx*PERIOD_US:>7},{(pidx+1)*PERIOD_US:>7}): "
              f"{used:>6}/{QUOTA_US}us used"
              f"{'  <- সম্পূর্ণ শেষ, থ্রটল ঘটেছে' if used == QUOTA_US else ''}")

এই sandbox-এ সত্যিই চালিয়ে পাওয়া output (macOS-এ Python 3.9.6, সম্পূর্ণ portable কোড — কোনো Linux syscall বা /sys/fs/cgroup লাগেনি):

cpu.max = "50000 100000"  (quota/period, microsecond)
=> প্রতি period-এ 50ms CPU বাজেট, cap = 0.50 CPU

burst অনুরোধ (arrival_us, duration_us):
  arrival=      0  duration=  80000
  arrival= 150000  duration=  30000
  arrival= 300000  duration= 120000

চলমান segment (RUN):
  t=[      0,   50000]  duration= 50000us  period#0
  t=[ 100000,  130000]  duration= 30000us  period#1
  t=[ 150000,  170000]  duration= 20000us  period#1
  t=[ 200000,  210000]  duration= 10000us  period#2
  t=[ 300000,  350000]  duration= 50000us  period#3
  t=[ 400000,  450000]  duration= 50000us  period#4
  t=[ 500000,  520000]  duration= 20000us  period#5

থ্রটল হওয়া segment (THROTTLED):
  t=[  50000,  100000]  duration= 50000us
  t=[ 170000,  200000]  duration= 30000us
  t=[ 350000,  400000]  duration= 50000us
  t=[ 450000,  500000]  duration= 50000us

মোট throttle সংখ্যা (nr_throttled): 4
মোট throttled সময় (throttled_usec): 180000us = 180.0ms

প্রতি period-এ ব্যবহৃত বাজেট (usage_usec / quota_usec):
  period#0 [      0, 100000):  50000/50000us used  <- সম্পূর্ণ শেষ, থ্রটল ঘটেছে
  period#1 [ 100000, 200000):  50000/50000us used  <- সম্পূর্ণ শেষ, থ্রটল ঘটেছে
  period#2 [ 200000, 300000):  10000/50000us used
  period#3 [ 300000, 400000):  50000/50000us used  <- সম্পূর্ণ শেষ, থ্রটল ঘটেছে
  period#4 [ 400000, 500000):  50000/50000us used  <- সম্পূর্ণ শেষ, থ্রটল ঘটেছে
  period#5 [ 500000, 600000):  20000/50000us used

কয়েকটা ফলাফল হাতে যাচাই করা যাক। প্রথম burst (arrival=0, duration=80000) period#0-এ শুরু হয়, পুরো 50000 বাজেট খরচ করে t=50000-এ থ্রটল হয় (বাকি 80000-50000=30000 কাজ জমে থাকে)। period#1 শুরু হলে (t=100000) বাজেট রিসেট হয়ে 50000 হয়, বাকি 30000 কাজ t=130000-এই শেষ হয়ে যায় — period#1-এর বাজেটের 20000 তখনও অব্যবহৃত থেকে যায়। দ্বিতীয় burst (arrival=150000, duration=30000) সেই একই period#1-এ শুরু হয়, বাকি 20000 বাজেট ব্যবহার করে t=170000-এ আবার থ্রটল হয় (period#1-এর বাজেট এবার সম্পূর্ণ শেষ), বাকি 10000 কাজ period#2-এর নতুন বাজেট দিয়ে t=210000-এ শেষ হয়। তৃতীয় burst (120000 microsecond, একটা একক period-এর quota-র চেয়ে অনেক বড়) তিনটা পুরো period (#3, #4) জুড়ে থ্রটল হয়ে, চতুর্থ period-এ (#5) গিয়ে শেষ হয় — output-এর সাথে সংখ্যায় সংখ্যায় মিলছে। মোট nr_throttled=4, মোট throttled_usec=180000 — এই সংখ্যাগুলোই একটা প্রকৃত cat cpu.stat-এ দেখা যেত, এই workload প্রকৃত Linux-এ web-tier group-এর ভেতরে চালানো হলে।