def __init__(s, stage_class, drop_controller_class=None):
def gen():
return ForwardingStage(stage_class)
gen.__name__ = stage_class.__name__
s.gen_stage = gen_stage(gen, drop_controller_class)()
UseInterface(s, s.gen_stage.interface)
s.wrap(s.gen_stage, ['forward'])
s.require(
MethodSpec(
'forward',
args={
'tag': PREG_IDX_NBITS,
'value': Bits(XLEN),
},
rets=None,
call=True,
rdy=False,
), )
s.forwarder = Forwarder()
s.connect_m(s.forwarder.in_forward, s.gen_stage.forward)
s.connect_m(s.forwarder.in_peek, s.gen_stage.peek)
s.connect_m(s.forwarder.in_take, s.gen_stage.take)
s.connect_m(s.forward, s.forwarder.forward)
s.connect_m(s.peek, s.forwarder.peek)
s.connect_m(s.take, s.forwarder.take)
if hasattr(s, 'kill_notify'):
s.connect_m(s.gen_stage.kill_notify, s.kill_notify)
else:
s.branch_target_.v = s.branch_target_fallthrough_
@s.combinational
def set_value_reg_input():
s.process_out.v = 0
s.process_out.hdr.v = s.msg_.hdr
s.process_out.result.v = s.msg_.hdr_pc + ILEN_BYTES
s.process_out.rd.v = s.msg_.rd
s.process_out.rd_val.v = s.msg_.rd_val
s.process_out.areg_d.v = s.msg_.areg_d
@s.combinational
def update_btb():
s.btb_write_key.v = s.msg_.hdr_pc
s.btb_write_value.v = s.branch_target_
s.btb_write_remove.v = not s.take_branch_
s.btb_write_call.v = s.process_call
def line_trace(s):
return s.process_in_.hdr_seq.hex()[2:]
def BranchDropController():
return PipelineKillDropController(
DropControllerInterface(ExecuteMsg(), ExecuteMsg(),
KillType(MAX_SPEC_DEPTH)))
Branch = gen_stage(BranchStage, BranchDropController)
s.counter.write_data.v = s.counter.read_data + 1
class Add2(Model):
def __init__(s):
UseInterface(s, StageInterface(Bits(8), Bits(8)))
s.connect(s.process_accepted, 1)
@s.combinational
def compute():
s.process_out.v = s.process_in_ + 2
CounterStage = gen_stage(Counter)
Add2Stage = gen_stage(Add2)
class PipelinedCounter(Model):
def __init__(s):
UseInterface(s, PipelineStageInterface(Bits(8), None))
s.stage_0 = CounterStage()
s.stage_1 = Add2Stage()
s.connect_m(s.stage_0.peek, s.stage_1.in_peek)
s.connect_m(s.stage_0.take, s.stage_1.in_take)
s.connect_m(s.stage_1.peek, s.peek)
s.connect_m(s.stage_1.take, s.take)
# This is ECALL, EBREAK, FENCE, FENCE_I
if s.process_in_.system_msg_func == SystemFunc.SYSTEM_FUNC_ECALL:
s.process_out.hdr_status.v = PipelineMsgStatus.PIPELINE_MSG_STATUS_EXCEPTION_RAISED
s.process_out.exception_info_mcause.v = ExceptionCode.ENVIRONMENT_CALL_FROM_M
s.process_out.exception_info_mtval.v = 0
elif s.process_in_.system_msg_func == SystemFunc.SYSTEM_FUNC_EBREAK:
s.process_out.hdr_status.v = PipelineMsgStatus.PIPELINE_MSG_STATUS_EXCEPTION_RAISED
s.process_out.exception_info_mcause.v = ExceptionCode.BREAKPOINT
s.process_out.exception_info_mtval.v = 0
elif s.process_in_.system_msg_func == SystemFunc.SYSTEM_FUNC_FENCE_I:
# Force a replay redirect
s.process_out.hdr_fence.v = 1
s.process_out.hdr_replay.v = 1
s.process_out.hdr_replay_next.v = 1
elif s.process_in_.system_msg_func == SystemFunc.SYSTEM_FUNC_FENCE:
s.process_out.hdr_fence.v = 1
else:
s.process_out.exception_info.v = s.process_in_.exception_info
def line_trace(s):
return s.process_in_.hdr_seq.hex()[2:]
def CSRDropController():
return PipelineKillDropController(
DropControllerInterface(ExecuteMsg(), ExecuteMsg(),
KillType(MAX_SPEC_DEPTH)))
CSR = gen_stage(CSRStage, CSRDropController)
def compute():
s.process_out.v = 0
s.process_out.hdr.v = s.process_in_.hdr
s.dataflow_write_call.v = 0
s.dataflow_write_tag.v = 0
s.dataflow_write_value.v = 0
if s.process_in_.hdr_status == PipelineMsgStatus.PIPELINE_MSG_STATUS_VALID:
s.process_out.rd_val_pair.v = s.process_in_.rd_val_pair
s.process_out.areg_d.v = s.process_in_.areg_d
# write the data if the destination is valid
s.dataflow_write_call.v = s.process_in_.rd_val and s.process_call
s.dataflow_write_tag.v = s.process_in_.rd
s.dataflow_write_value.v = s.process_in_.result
else:
s.process_out.exception_info.v = s.process_in_.exception_info
def line_trace(s):
return s.process_in_.hdr_seq.hex()[2:]
def WritebackDropController():
return PipelineKillDropController(
DropControllerInterface(WritebackMsg(), WritebackMsg(),
KillType(MAX_SPEC_DEPTH)))
Writeback = gen_stage(WritebackStage, WritebackDropController)
s.result.v = sext(s.data_d, XLEN)
@s.combinational
def set_process_out():
s.process_out.v = 0
s.process_out.hdr.v = s.process_in_.hdr
s.process_out.result.v = s.result
s.process_out.rd.v = s.process_in_.rd
s.process_out.rd_val.v = s.process_in_.rd_val
s.process_out.areg_d.v = s.process_in_.areg_d
def line_trace(s):
return s.process_in_.hdr_seq.hex()[2:]
MemRequest = gen_stage(MemRequestStage)
MemResponse = gen_stage(MemResponseStage)
def MemJointInterface():
return PipelineStageInterface(ExecuteMsg(), None)
class MemJoint(Model):
def __init__(s, interface):
UseInterface(s, interface)
s.mem_request = MemRequest(MemRequestInterface())
s.mem_response = MemResponse(MemResponseInterface())
s.require(
MethodSpec(
'recv_load',
@s.combinational
def set_output():
s.dispatched_.v = 0
s.dispatched_.hdr.v = s.process_in_.hdr
if s.process_in_.hdr_status != PipelineMsgStatus.PIPELINE_MSG_STATUS_VALID:
s.dispatched_.exception_info.v = s.process_in_.exception_info
# Copy exception info
s.dispatched_.exception_info.v = s.process_in_.exception_info
else:
s.dispatched_.rs1.v = s.read_value[0]
s.dispatched_.rs1_val.v = s.process_in_.rs1_val
s.dispatched_.rs2.v = s.read_value[1]
s.dispatched_.rs2_val.v = s.process_in_.rs2_val
s.dispatched_.rd.v = s.process_in_.rd
s.dispatched_.rd_val.v = s.process_in_.rd_val
s.dispatched_.areg_d.v = s.process_in_.areg_d
s.dispatched_.execution_data.v = s.process_in_.execution_data
def line_trace(s):
return s.process_in_.hdr_seq.hex()[2:]
def DispatchDropController():
return PipelineKillDropController(
DropControllerInterface(DispatchMsg(), DispatchMsg(),
KillType(MAX_SPEC_DEPTH)))
Dispatch = gen_stage(DispatchStage, DispatchDropController)
s.out_.hdr_spec_val.v = s.decoded_.speculative
s.out_.hdr_spec.v = s.register_spec_idx
s.out_.rs1_val.v = s.decoded_.rs1_val
s.out_.rs2_val.v = s.decoded_.rs2_val
s.out_.rd_val.v = s.decoded_.rd_val
# Copy over the aregs
s.out_.rs1.v = s.get_src_preg[0]
s.out_.rs2.v = s.get_src_preg[1]
s.out_.rd.v = s.get_dst_preg
s.out_.areg_d.v = s.decoded_.rd
# Copy the execution stuff
s.out_.execution_data.v = s.decoded_.execution_data
else:
s.out_.exception_info.v = s.decoded_.exception_info
@s.combinational
def set_accepted():
s.accepted_.v = s.register_success and s.register_call
def line_trace(s):
return s.register_seq.hex()[2:]
def RenameDropController():
return PipelineKillDropController(
DropControllerInterface(RenameMsg(), RenameMsg(),
KillType(MAX_SPEC_DEPTH)))
Rename = gen_stage(RenameStage, RenameDropController)
s.process_out.exception_info_mcause.v = ExceptionCode.ILLEGAL_INSTRUCTION
s.process_out.exception_info_mtval.v = zext(
s.process_in_.inst, XLEN)
else:
s.process_out.exception_info.v = s.process_in_.exception_info
def line_trace(s):
return '{:<25}'.format(rv64g.isa.disassemble_inst(s.process_in_.inst))
RedirectDropControllerInterface = DropControllerInterface
class RedirectDropController(Model):
def __init__(s, interface):
UseInterface(s, interface)
s.connect(s.check_out, s.check_in_)
@s.combinational
def handle_check_keep():
s.check_keep.v = not s.check_msg
def DecodeRedirectDropController():
return RedirectDropController(
RedirectDropControllerInterface(DecodeMsg(), DecodeMsg(), 1))
Decode = gen_stage(DecodeStage, DecodeRedirectDropController)