ফ্রেম অ্যালোকেশন স্ট্র্যাটেজি

১ · কতগুলো ফ্রেম কোন প্রসেসকে দেওয়া উচিত?

L33-L34-এ আমরা দেখেছি একটি একক প্রসেসের জন্য কোন পেজ রিপ্লেস করা উচিত। কিন্তু বাস্তবে একসাথে অনেক প্রসেস চলে, এবং ফিজিক্যাল ফ্রেমের সংখ্যা সীমিত। তাই একটি আরও মৌলিক প্রশ্ন আগে থেকেই সমাধান করতে হয়: ফ্রেম অ্যালোকেশন (Frame Allocation)Frame Allocationমোট সীমিত ফিজিক্যাল ফ্রেম একাধিক প্রসেসের মধ্যে কীভাবে ভাগ করে দেওয়া হবে তা ঠিক করার নিয়ম। — প্রতিটি প্রসেসকে ঠিক কতগুলো ফ্রেম দেওয়া হবে? খুব কম ফ্রেম দিলে সেই প্রসেস ক্রমাগত ফল্ট ঘটাবে (L35-এর থ্র্যাশিংয়ের ঝুঁকি); সব প্রসেসকে উদারভাবে বেশি দিতে গেলে মোট ফ্রেম ফুরিয়ে যাবে।

২ · ইকুয়াল বনাম প্রোপরশনাল অ্যালোকেশন

প্রোপরশনাল অ্যালোকেশন ইকুয়াল অ্যালোকেশনের চেয়ে অবশ্যই ন্যায্যতর, কিন্তু এটিরও একটি সীমাবদ্ধতা আছে — এটি শুধু প্রসেসের মোট আকার দেখে, তার বর্তমান প্রকৃত প্রয়োজন (L35-এর ওয়ার্কিং সেট) দেখে না। একটি বিশাল প্রোগ্রাম যদি এই মুহূর্তে তার একটি ছোট অংশ নিয়েই কাজ করে, প্রোপরশনাল অ্যালোকেশন তবুও তাকে তার পুরো আকারের অনুপাতে ফ্রেম দেবে — যার কিছু অংশ হয়তো আসলে অব্যবহৃত থেকে যাবে।

৩ · গ্লোবাল বনাম লোকাল রিপ্লেসমেন্ট স্কোপ

"কতগুলো ফ্রেম" প্রশ্নের পাশাপাশি আরেকটি স্বতন্ত্র প্রশ্ন আছে — একটি প্রসেসে পেজ ফল্ট ঘটলে, রিপ্লেসমেন্ট অ্যালগরিদম (L33-L34) কি শুধু সেই প্রসেসের নিজের ফ্রেমের মধ্যেই একটি ভিকটিম খুঁজবে, নাকি সিস্টেমের যেকোনো প্রসেসের ফ্রেম থেকে?

৪ · কোডে: প্রোপরশনাল অ্যালোকেশন গণনা

নিচের কোড সেলে একটি proportional_allocation() ফাংশন — প্রতিটি প্রসেসের নাম ও ভার্চুয়াল আকারের তালিকা এবং মোট ফ্রেম সংখ্যা দিলে, প্রতিটি প্রসেসের আনুপাতিক ফ্রেম-ভাগ গণনা করে। প্রথম উদাহরণে ভিন্ন আকারের প্রসেস, দ্বিতীয় উদাহরণে সমান আকারের প্রসেস কিন্তু এমন একটি ফ্রেম সংখ্যা যা রাউন্ডিংয়ের একটি বাস্তব সীমাবদ্ধতা দেখায়।

# প্রোপরশনাল ফ্রেম অ্যালোকেশন -- বাস্তব প্রসেস আকার নয়, টয় ভার্চুয়াল-সাইজ ডেটা

def proportional_allocation(processes, total_frames):
    """processes: [(name, virtual_size), ...] -- প্রতিটি প্রসেসের আনুপাতিক ফ্রেম-ভাগ গণনা।"""
    total_size = sum(size for _, size in processes)
    allocation = {}
    for name, size in processes:
        allocation[name] = round(total_frames * size / total_size)
    return allocation


# --- উদাহরণ ১: ভিন্ন ভিন্ন আকারের ৩টি প্রসেস ---
processes_1 = [("P1", 200), ("P2", 300), ("P3", 500)]
TOTAL_FRAMES_1 = 20

alloc_1 = proportional_allocation(processes_1, TOTAL_FRAMES_1)
print(f"উদাহরণ ১ -- প্রসেস: {processes_1}, মোট ফ্রেম: {TOTAL_FRAMES_1}")
for name, frames in alloc_1.items():
    print(f"  {name}: {frames} ফ্রেম বরাদ্দ")
print("  যোগফল:", sum(alloc_1.values()))

print()

# --- উদাহরণ ২: সমান আকারের ৩টি প্রসেস, কিন্তু ফ্রেম সংখ্যা ৩ দিয়ে নিঃশেষে বিভাজ্য নয় ---
processes_2 = [("Q1", 1000), ("Q2", 1000), ("Q3", 1000)]
TOTAL_FRAMES_2 = 10

alloc_2 = proportional_allocation(processes_2, TOTAL_FRAMES_2)
print(f"উদাহরণ ২ -- প্রসেস: {processes_2}, মোট ফ্রেম: {TOTAL_FRAMES_2}")
for name, frames in alloc_2.items():
    print(f"  {name}: {frames} ফ্রেম বরাদ্দ")

total_allocated = sum(alloc_2.values())
leftover = TOTAL_FRAMES_2 - total_allocated
print(f"  যোগফল: {total_allocated} (মোট উপলব্ধ {TOTAL_FRAMES_2}-এর মধ্যে {leftover}টি ফ্রেম রাউন্ডিংয়ের কারণে অবণ্টিত থেকে গেল)")