সিঙ্গেল-সাইকেল ডেটাপাথ ডিজাইন

# -- একটি টয় সিমুলেটেড ডেটাপাথ: রেজিস্টার ফাইল ও মেমরি Python dict/list, কোনো বাস্তব হার্ডওয়্যার অ্যাক্সেস নয়

class SingleCycleDatapath:
    def __init__(self, registers, data_memory):
        self.registers = registers   # রেজিস্টার ফাইল (L26)
        self.data_memory = data_memory
        self.pc = 0

    def run_instruction(self, instr):
        op = instr['op']
        print(f"\n=== ইনস্ট্রাকশন: {op}  (PC={self.pc}) ===")

        # ----- Fetch -----
        fetched_pc = self.pc
        self.pc += 1
        print(f"[Fetch]     PC={fetched_pc} থেকে ইনস্ট্রাকশন আনা হলো, PC এখন {self.pc}")

        # ----- Decode: রেজিস্টার ফাইল পড়া -----
        rs1_val = self.registers[instr['rs1']]
        rs2_val = self.registers[instr['rs2']] if op == 'ADD' else None
        if op == 'ADD':
            print(f"[Decode]    রেজিস্টার ফাইল পড়া হলো: r{instr['rs1']}={rs1_val}, r{instr['rs2']}={rs2_val}")
        else:
            print(f"[Decode]    রেজিস্টার ফাইল পড়া হলো: r{instr['rs1']}={rs1_val}, immediate={instr['imm']}")

        # ----- Execute: ALU -----
        if op == 'ADD':
            alu_result = rs1_val + rs2_val
            print(f"[Execute]   ALU: {rs1_val} + {rs2_val} = {alu_result}")
        elif op == 'ADDI':
            alu_result = rs1_val + instr['imm']
            print(f"[Execute]   ALU: {rs1_val} + {instr['imm']} = {alu_result}")
        elif op == 'LOAD':
            alu_result = rs1_val + instr['imm']   # ঠিকানা গণনা
            print(f"[Execute]   ALU (ঠিকানা গণনা): {rs1_val} + {instr['imm']} = {alu_result}")

        # ----- Memory: শুধু LOAD-এর জন্য কার্যকর -----
        mem_value = None
        if op == 'LOAD':
            mem_value = self.data_memory.get(alu_result, 0)
            print(f"[Memory]    mem[{alu_result}] পড়া হলো = {mem_value}")
        else:
            print(f"[Memory]    (এই ইনস্ট্রাকশনের মেমরি অ্যাক্সেসের দরকার নেই -- সাইকেল অপেক্ষা করে)")

        # ----- Writeback -----
        result = mem_value if op == 'LOAD' else alu_result
        if instr['rd'] != 0:
            self.registers[instr['rd']] = result
        print(f"[Writeback] r{instr['rd']} = {result}")
        return result


registers = [0, 10, 20, 0, 0, 0, 100, 0]   # r1=10, r2=20, r6=100 (LOAD-এর বেস ঠিকানা)
data_memory = {100: 42}                      # mem[100] = 42

datapath = SingleCycleDatapath(registers, data_memory)

# ইনস্ট্রাকশন ১: R-type ADD  -- r3 = r1 + r2
datapath.run_instruction({'op': 'ADD', 'rd': 3, 'rs1': 1, 'rs2': 2})
# ইনস্ট্রাকশন ২: I-type ADDI -- r4 = r1 + 5
datapath.run_instruction({'op': 'ADDI', 'rd': 4, 'rs1': 1, 'imm': 5})
# ইনস্ট্রাকশন ৩: LOAD -- r5 = mem[r6 + 0]
datapath.run_instruction({'op': 'LOAD', 'rd': 5, 'rs1': 6, 'imm': 0})

print("\n--- চূড়ান্ত রেজিস্টার স্টেট ---")
print(f"r3 (ADD  ফলাফল) = {registers[3]}   প্রত্যাশিত: 10+20=30")
print(f"r4 (ADDI ফলাফল) = {registers[4]}   প্রত্যাশিত: 10+5=15")
print(f"r5 (LOAD ফলাফল) = {registers[5]}   প্রত্যাশিত: mem[100]=42")

assert registers[3] == 30 and registers[4] == 15 and registers[5] == 42
print("\nতিনটি ভিন্ন ইনস্ট্রাকশন টাইপই সঠিক ফলাফল দিয়েছে।")