def __init__(self, memory, start_address):
self.memory = memory
self.start_address = start_address
self.register_file = RegisterFile()
self.data_memory_key_fn = lambda: -777
self.data_memory = defaultdict(self.data_memory_key_fn)
self.cycle_count = 0
self.instr_count = 0
self.PC = 0
self.fetch_input_buffer = FetchInputBuffer({
'PC':
self.start_address,
'instr_count':
self.instr_count,
})
self.fetcher_buffer = FetcherBuffer()
self.fetch_stage = FetchStage(self.memory, self.fetch_input_buffer,
self.fetcher_buffer)
self.decoder_buffer = DecoderBuffer()
self.decode_stage = DecodeStage(self.fetcher_buffer,
self.decoder_buffer,
self.register_file)
self.executer_buffer = ExecuterBuffer()
self.execute_stage = ExecuteStage(self.decoder_buffer,
self.executer_buffer)
self.memory_buffer = MemoryBuffer()
self.memory_stage = MemoryStage(self.executer_buffer,
self.memory_buffer, self.data_memory)
self.write_back_stage = WriteBackStage(self.memory_buffer,
self.register_file)
def setUp(self):
self.instruction_string = 'R ADD R1 R2 R3'
self.instr = Instruction.Instruction(
self.instruction_string.strip().split())
self.memory = Memory.Memory([self.instruction_string.strip().split()])
self.fetch_input_buffer = FetchInputBuffer({
'PC': 0,
'instr_count': 0,
})
self.fetcher_buffer = FetcherBuffer({})
self.fetch_stage = fetch_stage.FetchStage(self.memory,
self.fetch_input_buffer,
self.fetcher_buffer)
def test_fetch_instruction_normal(self):
ans_fetcher_buffer = FetcherBuffer({
'PC':
0,
'instr':
Instruction.Instruction(self.memory[0]),
'npc':
4
})
ans_fetch_input_buffer = FetchInputBuffer({
'PC': 4,
'instr_count': 1,
})
self.fetch_stage.fetch_instruction()
self.assertEqual(self.fetch_stage.fetcher_buffer, ans_fetcher_buffer)
self.assertEqual(self.fetch_stage.fetch_input_buffer,
ans_fetch_input_buffer)
def get_stage_output(memory, register_file, pc, instr_count, stage_name):
"""Return the output buffer of stage given the initial conditions.
All the stages before stage_name will be executed.
Arguments:
- `memory`:
- `register_file`:
- `pc`:
- `stage_name`:
TODO: Maybe just take the stages as input later.
"""
fetch_input_buffer = FetchInputBuffer({
'PC': pc,
'instr_count': instr_count,
})
fetcher_buffer = FetcherBuffer()
fetch_stage = FetchStage(memory, fetch_input_buffer, fetcher_buffer)
fetch_stage.fetch_instruction()
if stage_name == 'fetch':
return fetch_stage.fetcher_buffer
decode_stage = DecodeStage(fetch_stage.fetcher_buffer, DecoderBuffer(),
register_file)
decode_stage.decode_instruction()
if stage_name == 'decode':
return decode_stage.decoder_buffer
execute_stage = ExecuteStage(decode_stage.decoder_buffer,
ExecuterBuffer())
execute_stage.execute()
if stage_name == 'execute':
return execute_stage.executer_buffer
data_memory_key_fn = lambda: -1
data_memory = defaultdict(data_memory_key_fn)
memory_stage = MemoryStage(execute_stage.executer_buffer,
MemoryBuffer(), data_memory)
memory_stage.do_memory_operation()
if stage_name == 'memory':
return memory_stage.memory_buffer
def test_execute_cycles_BEQ_true(self):
instruction_list = [
'I BEQ R2 R5 4',
'R ADD R1 R2 R3',
'R ADD R1 R2 R3',
'R ADD R2 R0 R1',
'R ADD R3 R0 R2',
'J J 3',
'I ADDI R9 R9 999',
]
instruction_list = [
instruction_string.split()
for instruction_string in instruction_list
]
memory = Memory.Memory(instruction_list)
processor = Processor.Processor(memory, 0)
processor.execute_cycles(3)
self.assertEqual(processor.execute_stage.branch_pc, 20)
self.assertEqual(processor.fetch_stage.fetch_input_buffer.PC, 20)
self.assertEqual(processor.executer_buffer, ExecuterBuffer())
self.assertEqual(processor.decoder_buffer, DecoderBuffer())
self.assertEqual(processor.fetcher_buffer, FetcherBuffer())
def test_fetch_instruction_out_of_bound_pc(self):
self.fetch_stage.fetcher_buffer = FetcherBuffer()
self.fetch_stage.fetcher_buffer.PC = 707
self.fetch_input_buffer.PC = 200000
self.fetch_stage.fetch_instruction()
def test_fetch_instruction_decoder_stall(self):
init_fetcher_buffer = FetcherBuffer({'foo': 123})
self.fetch_stage.fetcher_buffer = FetcherBuffer({'foo': 123})
self.fetch_stage.fetch_instruction(True)
self.assertEqual(self.fetch_stage.fetcher_buffer, init_fetcher_buffer)
