মাইক্রোকন্ট্রোলারে ভন নিউম্যান বনাম হার্ভার্ড আর্কিটেকচার

class HarvardCpu:
    # হার্ভার্ড আর্কিটেকচার: প্রোগ্রাম মেমরি ও ডেটা মেমরি সম্পূর্ণ আলাদা বাসে, আলাদা মেমরিতে
    def __init__(self, program, initial_data=None):
        self.program_memory = dict(enumerate(program))  # আলাদা কোড মেমরি
        self.data_memory = dict(initial_data or {})      # আলাদা ডেটা মেমরি
        self.ticks_used = 0
        self.bus_access_log = []

    def run(self):
        pc = 0
        while pc in self.program_memory:
            self.ticks_used += 1
            instr = self.program_memory[pc]
            # হার্ভার্ডে ফেচ ও ডেটা-অ্যাক্সেস একই টিকে, দুটো ভিন্ন বাসে ঘটতে পারে
            self.bus_access_log.append((self.ticks_used, "code-bus", "fetch", pc))
            if instr[0] == "LOAD":
                value = self.data_memory.get(instr[1], 0)
                self.bus_access_log.append((self.ticks_used, "data-bus", "read", instr[1], value))
            elif instr[0] == "STORE":
                self.data_memory[instr[1]] = instr[2]
                self.bus_access_log.append((self.ticks_used, "data-bus", "write", instr[1], instr[2]))
            pc += 1
        return self.ticks_used


class VonNeumannCpu:
    # ভন নিউম্যান আর্কিটেকচার: কোড ও ডেটা একই মেমরি, একই বাসে -- একবারে একটি অ্যাক্সেসই সম্ভব
    def __init__(self, program, initial_data=None):
        self.memory = dict(enumerate(program))  # কোড মেমরির নিচু ঠিকানায় (0, 1, 2, ...)
        self.data_base = 1000                   # ডেটা একই মেমরিতে, ভিন্ন ঠিকানা রেঞ্জে
        for addr, value in (initial_data or {}).items():
            self.memory[self.data_base + addr] = value
        self.ticks_used = 0
        self.bus_access_log = []

    def run(self):
        pc = 0
        while pc in self.memory and isinstance(self.memory[pc], tuple):
            instr = self.memory[pc]
            self.ticks_used += 1  # ফেচের জন্য একটি টিক
            self.bus_access_log.append((self.ticks_used, "shared-bus", "fetch", pc))
            if instr[0] == "LOAD":
                addr = self.data_base + instr[1]
                self.ticks_used += 1  # একই বাস -- ডেটা রিডের জন্য আলাদা, দ্বিতীয় টিক লাগে
                value = self.memory.get(addr, 0)
                self.bus_access_log.append((self.ticks_used, "shared-bus", "read", addr, value))
            elif instr[0] == "STORE":
                addr = self.data_base + instr[1]
                self.ticks_used += 1  # একই বাস -- ডেটা রাইটের জন্য আলাদা, দ্বিতীয় টিক লাগে
                self.memory[addr] = instr[2]
                self.bus_access_log.append((self.ticks_used, "shared-bus", "write", addr, instr[2]))
            pc += 1
        return self.ticks_used


# একই প্রোগ্রাম: ঠিকানা 0 থেকে লোড, ঠিকানা 1-এ স্টোর, ঠিকানা 1 থেকে লোড, ঠিকানা 2-এ স্টোর
program = [
    ("LOAD", 0),
    ("STORE", 1, 42),
    ("LOAD", 1),
    ("STORE", 2, 99),
]
initial_data = {0: 7}

harvard = HarvardCpu(program, initial_data)
h_ticks = harvard.run()
print(f"হার্ভার্ড আর্কিটেকচার -- মোট টিক লাগলো: {h_ticks}")
for entry in harvard.bus_access_log:
    print("  ", entry)

von = VonNeumannCpu(program, initial_data)
v_ticks = von.run()
print(f"\nভন নিউম্যান আর্কিটেকচার -- মোট টিক লাগলো: {v_ticks}")
for entry in von.bus_access_log:
    print("  ", entry)

print(f"\nএকই প্রোগ্রামের জন্য ভন নিউম্যান হার্ভার্ডের তুলনায় {v_ticks - h_ticks} বেশি টিক ব্যবহার করলো "
      f"({v_ticks / h_ticks:.1f}x ধীর) -- কারণ একই বাসে ফেচ ও ডেটা-অ্যাক্সেস একসাথে করা যায় না।")