ডেটা হ্যাজার্ড ও ফরওয়ার্ডিং

# ডেটা হ্যাজার্ড ও ফরওয়ার্ডিং -- পাইপলাইন স্টেজ-টাইমিং সিমুলেশন
IF, ID, EX, MEM, WB = "IF", "ID", "EX", "MEM", "WB"
STAGES = [IF, ID, EX, MEM, WB]

def stage_at_cycle(start_cycle, stage_name):
    """start_cycle-এ IF শুরু হওয়া ইনস্ট্রাকশন stage_name স্টেজে কোন সাইকেলে পৌঁছাবে"""
    return start_cycle + STAGES.index(stage_name)

def simulate_two_add(forwarding_enabled):
    """I1: ADD r1,r2,r3  তারপর  I2: ADD r4,r1,r5 -- ডেটা হ্যাজার্ড"""
    registers = {"r1": 10, "r2": 20, "r3": 30, "r5": 5}  # শুরুর (পুরনো) রেজিস্টার স্টেট
    i1_start, i2_start = 1, 2
    i1_result = registers["r2"] + registers["r3"]  # I1 আসলে যা লিখবে (নতুন r1)

    i1_ex_cycle = stage_at_cycle(i1_start, EX)
    i1_wb_cycle = stage_at_cycle(i1_start, WB)
    i2_id_cycle = stage_at_cycle(i2_start, ID)
    i2_ex_cycle = stage_at_cycle(i2_start, EX)

    if forwarding_enabled:
        # EX/MEM -> EX ফরওয়ার্ড পাথ: I1-এর EX ফলাফল ঠিক I2-এর EX-এ পৌঁছায় কিনা যাচাই
        r1_used = i1_result if i1_ex_cycle == i2_ex_cycle - 1 else registers["r1"]
        source = "ফরওয়ার্ড করা (EX/MEM -> EX)"
    else:
        # রেজিস্টার ফাইল থেকেই সরাসরি পড়া -- WB সম্পন্ন না হওয়া পর্যন্ত পুরনো মান
        r1_used = i1_result if i1_wb_cycle <= i2_id_cycle else registers["r1"]
        source = "রেজিস্টার ফাইল থেকে সরাসরি"

    r4_result = r1_used + registers["r5"]
    correct = i1_result + registers["r5"]
    return {"r1_used": r1_used, "source": source, "r4_result": r4_result,
            "correct": correct, "is_correct": r4_result == correct}

print("=== ADD-then-ADD, ফরওয়ার্ডিং ছাড়া ===")
no_fwd = simulate_two_add(forwarding_enabled=False)
for k, v in no_fwd.items(): print(f"  {k}: {v}")

print("\n=== ADD-then-ADD, ফরওয়ার্ডিং সহ ===")
with_fwd = simulate_two_add(forwarding_enabled=True)
for k, v in with_fwd.items(): print(f"  {k}: {v}")

assert not no_fwd["is_correct"], "ফরওয়ার্ডিং ছাড়া ভুল (স্টেল) মান পাওয়ার কথা"
assert with_fwd["is_correct"], "ফরওয়ার্ডিং সহ সঠিক মান পাওয়ার কথা"
print(f"\nযাচাই: ফরওয়ার্ডিং ছাড়া r4={no_fwd['r4_result']} (ভুল, প্রত্যাশিত {no_fwd['correct']}), "
      f"ফরওয়ার্ডিং সহ r4={with_fwd['r4_result']} (সঠিক)")

def simulate_load_use(with_stall):
    """I1: LOAD r1,0(r2)  তারপর  I2: ADD r4,r1,r5 -- লোড-ইউজ হ্যাজার্ড"""
    memory = {20: 99}
    registers = {"r1": 0, "r2": 20, "r5": 5}
    i1_start = 1
    i1_mem_cycle = stage_at_cycle(i1_start, MEM)  # লোড হওয়া মান এই সাইকেল শেষে প্রস্তুত হয়
    loaded_value = memory[registers["r2"]]

    i2_start = i1_start + 2 if with_stall else i1_start + 1  # ১ সাইকেল বাবল যোগ হলো কিনা
    i2_ex_cycle = stage_at_cycle(i2_start, EX)

    # MEM/WB -> EX ফরওয়ার্ড: I2-এর EX, I1-এর MEM-এর পরের সাইকেলে হলে তবেই মান প্রস্তুত থাকে
    r1_used = loaded_value if i2_ex_cycle > i1_mem_cycle else registers["r1"]
    r4_result = r1_used + registers["r5"]
    correct = loaded_value + registers["r5"]
    return {"i1_mem_cycle": i1_mem_cycle, "i2_ex_cycle": i2_ex_cycle,
            "r1_used": r1_used, "r4_result": r4_result,
            "correct": correct, "is_correct": r4_result == correct}

print("\n=== LOAD-then-ADD, স্টল ছাড়া (ফরওয়ার্ডিং থাকা সত্ত্বেও) ===")
no_stall = simulate_load_use(with_stall=False)
for k, v in no_stall.items(): print(f"  {k}: {v}")

print("\n=== LOAD-then-ADD, ১ সাইকেল স্টল সহ ===")
stalled = simulate_load_use(with_stall=True)
for k, v in stalled.items(): print(f"  {k}: {v}")

assert not no_stall["is_correct"], "স্টল ছাড়া লোড-ইউজ ভুল মান দেওয়ার কথা"
assert stalled["is_correct"], "১ সাইকেল স্টল সহ সঠিক মান পাওয়ার কথা"
print(f"\nযাচাই: স্টল ছাড়া r4={no_stall['r4_result']} (ভুল), ১ সাইকেল স্টল সহ r4={stalled['r4_result']} (সঠিক)")