রেজিস্টার ফাইল ও CPU রেজিস্টার

১ · রেজিস্টার ফাইল কী

L15-এ আমরা দেখেছি কীভাবে N-টি D ফ্লিপ-ফ্লপ মিলে একটি N-বিট রেজিস্টারএকটি সাধারণ ক্লক শেয়ার করা N-টি D ফ্লিপ-ফ্লপের গ্রুপ, যা একসাথে একটি N-বিট মান সংরক্ষণ করে। তৈরি হয়। রেজিস্টার ফাইল হলো এই ধারণারই বাস্তব, CPU-স্কেল বাস্তবায়ন — একটি ফিক্সড, ছোট সংখ্যক (অনেক RISC ISA-তে যেমন ৩২টি) সাধারণ-উদ্দেশ্য রেজিস্টারকে একটি অ্যাড্রেসযোগ্য অ্যারে হিসেবে সংগঠিত করা, যেখানে read ও write উভয় পোর্ট থাকে — অর্থাৎ L24-এর ইনস্ট্রাকশন ফরম্যাটে থাকা রেজিস্টার-নম্বর ফিল্ড (rd, rs1, rs2) সরাসরি এই অ্যারের একটি নির্দিষ্ট রেজিস্টার নির্বাচন করে।

২ · রেজিস্টার কেন মেমরির চেয়ে দ্রুত

এই প্রশ্নের উত্তর সরাসরি M8-এর মেমরি হায়ারার্কি আলোচনার প্রিভিউ — রেজিস্টার সেই হায়ারার্কির একদম শীর্ষে, সবচেয়ে দ্রুত ক্যাশের চেয়েও দ্রুত। কারণ রেজিস্টারগুলো ফিজিক্যালি CPU চিপের ভেতরেই তৈরি, ঠিক M3-এর একই ফ্লিপ-ফ্লপ প্রযুক্তি দিয়ে — এদের পৌঁছাতে কোনো আলাদা বাস বা ইন্টারকানেক্ট পার হতে হয় না, যেখানে মেমরি একটি সম্পূর্ণ আলাদা, অনেক বড়, এবং অনেক ধীর স্ট্রাকচার (M9-এ বিস্তারিত)। এই কারণেই কম্পাইলার সবসময় চেষ্টা করে যতটা সম্ভব ডেটা রেজিস্টারে রাখতে, মেমরিতে বারবার যাওয়া এড়িয়ে।

৩ · বিশেষ-উদ্দেশ্য রেজিস্টার

সাধারণ-উদ্দেশ্য রেজিস্টার ছাড়াও, প্রতিটি CPU-তে কয়েকটি নির্দিষ্ট, বিশেষ ভূমিকার রেজিস্টার থাকে —

• Program Counter (PC): পরবর্তী ফেচ করতে হবে এমন ইনস্ট্রাকশনের মেমরি অ্যাড্রেস ধরে রাখে — সরাসরি M6-এর ফেচ স্টেজের ভিত্তি।
• Instruction Register (IR): ফেচ করার পর বর্তমানে এক্সিকিউট হতে থাকা ইনস্ট্রাকশনটি ধরে রাখে।
• Stack Pointer (SP): কল স্ট্যাকের শীর্ষের অবস্থান ট্র্যাক করে।
• Flags/Status রেজিস্টার: কন্ডিশন ফলাফল ধরে রাখে — zero-flag, negative-flag, overflow-flag (সরাসরি L18/L19-এর overflow-detection ধারণার হার্ডওয়্যার-স্থায়ী রূপ, যা branch ইনস্ট্রাকশন পরীক্ষা করতে পারে)।

নিচের কোড সেলে একটি RegisterFile ক্লাস সিমুলেট করা হচ্ছে — N-টি সাধারণ-উদ্দেশ্য রেজিস্টার, একটি আলাদা PC, ও একটি flags ডিকশনারি নিয়ে। লক্ষ্য করুন register 0-কে বাস্তব RISC ISA-এর মতোই হার্ডওয়্যার্ড টু জিরো করা হয়েছে — এতে লেখার চেষ্টা করলেও নিঃশব্দে উপেক্ষিত হয়।

# CPU-এর ভেতরের রেজিস্টার ফাইল -- টয় সিমুলেশন, বাস্তব হার্ডওয়্যার অ্যাক্সেস নয়
class RegisterFile:
    def __init__(self, n_registers=8):
        self.n_registers = n_registers
        self.registers = [0] * n_registers
        self.pc = 0
        self.flags = {"zero": 0, "negative": 0, "overflow": 0}

    def read(self, reg_num):
        if reg_num == 0:
            return 0  # বাস্তব RISC ISA-র মতোই -- register 0 সবসময় 0 পড়ে
        return self.registers[reg_num]

    def write(self, reg_num, value):
        if reg_num == 0:
            return  # হার্ডওয়্যার্ড টু জিরো -- লেখার চেষ্টা নিঃশব্দে উপেক্ষিত হয়
        self.registers[reg_num] = value

    def update_flags(self, alu_result, bits=8):
        """একটি সিমুলেটেড ALU অপারেশনের ফলাফল থেকে flags আপডেট করে"""
        max_signed = 2 ** (bits - 1) - 1
        min_signed = -2 ** (bits - 1)
        self.flags["zero"] = 1 if alu_result == 0 else 0
        self.flags["negative"] = 1 if alu_result < 0 else 0
        self.flags["overflow"] = 1 if (alu_result > max_signed or alu_result < min_signed) else 0

rf = RegisterFile(n_registers=8)

# --- register 0 হার্ডওয়্যার্ড টু জিরো -- write করার চেষ্টা করেও প্রভাব নেই ---
rf.write(0, 999)
print("register 0-তে 999 লেখার চেষ্টার পর read(0):", rf.read(0))

# --- সাধারণ রেজিস্টারে স্বাভাবিক read/write ---
rf.write(3, 42)
print("register 3-এ 42 লেখার পর read(3):", rf.read(3))

# --- ALU ফলাফল অনুযায়ী flags আপডেট -- zero-result কেস ---
rf.update_flags(0)
print("\nALU ফলাফল 0 হলে flags:", rf.flags)

# --- ALU ফলাফল অনুযায়ী flags আপডেট -- negative-result কেস ---
rf.update_flags(-5)
print("ALU ফলাফল -5 হলে flags:", rf.flags)

# --- 8-বিট সাইনড রেঞ্জ ছাড়িয়ে যাওয়া ফলাফল -- overflow কেস ---
rf.update_flags(200, bits=8)
print("ALU ফলাফল 200 (8-বিট সাইনড রেঞ্জের বাইরে) হলে flags:", rf.flags)