মাল্টিপ্রসেসর শিডিউলিং

১ · একক CPU থেকে মাল্টি-কোরে

L09 থেকে L12 পর্যন্ত আমরা যা শিখেছি তা ধরে নিয়েছিল মাত্র একটি CPU আছে — সেই একটি CPU-এর জন্য কোন প্রসেস পরবর্তীতে চলবে তা ঠিক করাই ছিল শিডিউলারের একমাত্র কাজ। কিন্তু আধুনিক প্রায় সব ডিভাইসেই একাধিক CPU কোরCoreএকটি একক প্রসেসর চিপের ভেতরে থাকা স্বাধীন প্রসেসিং ইউনিট, যা একই সাথে ভিন্ন ভিন্ন প্রসেসের ইন্সট্রাকশন চালাতে পারে। থাকে — এখন প্রশ্নটা শুধু "পরবর্তীতে কে চলবে" নয়, বরং "পরবর্তীতে কে, কোন কোরে চলবে, এবং কাজ কীভাবে কোরগুলোর মধ্যে সমানভাবে ভাগ হবে।"

২ · লোড ব্যালেন্সিং — পুশ বনাম পুল মাইগ্রেশন

লোড ব্যালেন্সিং (Load Balancing)Load Balancingএকাধিক CPU কোরের মধ্যে কাজ সমানভাবে বণ্টিত রাখার প্রক্রিয়া, যাতে কোনো কোর অলস বসে না থাকে অথচ অন্য কোর ওভারলোডেড না হয়। নিশ্চিত করে কোনো একটি কোর অতিরিক্ত ব্যস্ত থাকা অবস্থায় আরেকটি কোর অলস বসে না থাকে। দুটি পদ্ধতি — পুশ মাইগ্রেশন: একটি কেন্দ্রীয় প্রক্রিয়া নিয়মিতভাবে ব্যস্ত কোর থেকে অলস কোরে প্রসেস সরিয়ে দেয়। পুল মাইগ্রেশন: অলস কোর নিজেই সক্রিয়ভাবে ব্যস্ত কোরের কিউ থেকে কাজ "চুরি" করে নেয় (work stealing)।

৩ · প্রসেসর অ্যাফিনিটি

একটি প্রসেস একবার কোনো কোরে চললে, তার ডেটার কিছু অংশ সেই কোরের ক্যাশে থেকে যায় — একে অন্য কোরে সরালে সেই ক্যাশ-উষ্ণতা (warm cache) নষ্ট হয়ে যায় এবং নতুন কোরে ক্যাশ মিস (ব্যয়বহুল) বেড়ে যায়। তাই শিডিউলার যতটা সম্ভব একটি প্রসেসকে একই কোরে রাখার চেষ্টা করে — একে প্রসেসর অ্যাফিনিটি (Processor Affinity)Processor Affinityএকটি প্রসেসকে একই CPU কোরে রাখার প্রবণতা বা প্রয়োজনীয়তা, যাতে ক্যাশ-উষ্ণতার সুবিধা বজায় থাকে। বলা হয়। সফট অ্যাফিনিটি একটি পছন্দ মাত্র (সম্ভব হলে একই কোরে রাখা হবে), আর হার্ড অ্যাফিনিটি একটি স্পষ্ট বাধ্যবাধকতা (প্রসেসটিকে নির্দিষ্ট কোর(গুলো) ছাড়া অন্য কোথাও চালানোই যাবে না)।

৪ · একটি লোড-ব্যালেন্সিং সিমুলেশন

নিচের কোড সেলে প্রতিটি কোরের জন্য একটি "কিউ" (বার্স্ট টাইমের তালিকা) আছে। rebalance() ফাংশনটি সবচেয়ে ব্যস্ত ও সবচেয়ে অলস কোরের লোডের পার্থক্য একটি থ্রেশহোল্ডের চেয়ে বেশি হলে, ব্যস্ত কোর থেকে ছোট একটি কাজ অলস কোরে সরিয়ে দেয় (পুল মাইগ্রেশনের মতো — অলস কোর কাজ "টেনে নেয়")।

# সরল লোড-ব্যালেন্সিং সিমুলেশন -- toy in-memory ডেটা, real CPU cores নয়
cores = {
    "core0": [8, 7],
    "core1": [3],
    "core2": [2, 2],
}

def total_load(core_queue):
    return sum(core_queue)

def show(cores):
    for name, q in cores.items():
        print(f"  {name}: {q} -> load = {total_load(q)}")

def rebalance(cores, threshold=3):
    loads = {name: total_load(q) for name, q in cores.items()}
    busiest = max(loads, key=loads.get)
    idlest = min(loads, key=loads.get)
    if loads[busiest] - loads[idlest] <= threshold or not cores[busiest]:
        return False
    job = min(cores[busiest])       # সবচেয়ে ছোট বার্স্ট মাইগ্রেট করি -- ওভারশুট এড়াতে
    cores[busiest].remove(job)
    cores[idlest].append(job)
    print(f"  মাইগ্রেশন: {busiest} (load {loads[busiest]}) -> {idlest} (load {loads[idlest]}), burst={job}")
    return True

print("--- প্রাথমিক অবস্থা (আনব্যালান্সড) ---")
show(cores)

round_num = 1
while rebalance(cores, threshold=3) and round_num <= 5:
    print(f"\n--- রিব্যালান্সিং রাউন্ড {round_num}-এর পর ---")
    show(cores)
    round_num += 1

print("\n--- চূড়ান্ত (ব্যালান্সড) অবস্থা ---")
show(cores)