coreblocks.frontend package

Subpackages

• coreblocks.frontend.bpu package
  • Submodules
  • coreblocks.frontend.bpu.bpu module
    • BranchPredictionUnit
      • BranchPredictionUnit.__init__()
      • BranchPredictionUnit.flush
      • BranchPredictionUnit.request
      • BranchPredictionUnit.update
      • BranchPredictionUnit.write_fetch_target
      • BranchPredictionUnit.write_prediction_details
  • coreblocks.frontend.bpu.component module
    • BPUComponent
      • BPUComponent.__init__()
      • BPUComponent.update
    • BPUComponentLayouts
      • BPUComponentLayouts.__init__()
      • BPUComponentLayouts.cfi_hints()
      • BPUComponentLayouts.cfi_prediction()
    • CfiPredictor
      • CfiPredictor.__init__()
      • CfiPredictor.flush
      • CfiPredictor.request_s0
      • CfiPredictor.response_s1
      • CfiPredictor.response_s2
    • DirectionPredictor
      • DirectionPredictor.__init__()
      • DirectionPredictor.accept_s1_hints
      • DirectionPredictor.flush
      • DirectionPredictor.request_s0
      • DirectionPredictor.response_s2
    • FastPredictor
      • FastPredictor.__init__()
      • FastPredictor.flush
      • FastPredictor.request_s0
      • FastPredictor.response_s1
  • coreblocks.frontend.bpu.micro_btb module
    • MicroBTB
      • MicroBTB.__init__()
  • coreblocks.frontend.bpu.ras module
    • RAS
      • RAS.__init__()
      • RAS.peek
      • RAS.recover
      • RAS.update
  • Module contents
• coreblocks.frontend.decoder package
  • Submodules
  • coreblocks.frontend.decoder.decode_stage module
    • Decode
      • Decode.__init__()
      • Decode.decode
    • DecodeStage
      • DecodeStage.__init__()
  • coreblocks.frontend.decoder.instr_decoder module
    • InstrDecoder
      • InstrDecoder.__init__()
  • coreblocks.frontend.decoder.instr_description module
    • Encoding
      • Encoding.__init__()
      • Encoding.funct12
      • Encoding.funct3
      • Encoding.funct7
      • Encoding.instr_type_override
      • Encoding.opcode
      • Encoding.rd_zero
      • Encoding.rs1_zero
      • Encoding.rs2_zero
  • coreblocks.frontend.decoder.rvc module
    • InstrDecompress
      • InstrDecompress.__init__()
      • InstrDecompress.decompr_reg()
      • InstrDecompress.instr_mux()
    • is_instr_compressed()
  • Module contents
• coreblocks.frontend.fetch package
  • Submodules
  • coreblocks.frontend.fetch.fetch module
    • FetchUnit
      • FetchUnit.__init__()
      • FetchUnit.check_stale
      • FetchUnit.cont
      • FetchUnit.fetch_request
      • FetchUnit.fetch_writeback
      • FetchUnit.flush
      • FetchUnit.ras_peek
      • FetchUnit.ras_predict
      • FetchUnit.read_prediction
    • Predecoder
      • Predecoder.__init__()
    • PredictionChecker
      • PredictionChecker.__init__()
  • Module contents

Submodules

coreblocks.frontend.fetch_addr_unit module

class coreblocks.frontend.fetch_addr_unit.FetchAddressUnit

Bases: Elaboratable

Owns the speculative fetch program counter and arbitrates all frontend redirects. It selects the next fetch PC based on reset, backend redirects, IFU redirects, and branch prediction results.

__init__(gen_params: GenParams)

backend_redirect: PROVIDED: 1>]

Redirect the fetch PC after a misprediction resolved by the backend.

ifu_redirect: PROVIDED: 1>]

Redirect the fetch PC after a misprediction detected by the IFU, or - when pc_valid is low - invalidate it, because the IFU doesn’t know where to fetch next.

read: PROVIDED: 1>]

Consume the current fetch PC. Blocks until a valid PC is available.

write: PROVIDED: 1>]

Supply the next fetch PC (e.g. from a BPU prediction). Requires the current PC to have been consumed.

coreblocks.frontend.frontend module

class coreblocks.frontend.frontend.CoreFrontend

Bases: Elaboratable

Frontend of the core.

__init__(*, gen_params: GenParams, instr_bus: BusMasterInterface)

consume_instr: PROVIDED: 1>]

Consume a single decoded instruction.

get_exception_information: REQUIRED: 2>]

redirect: PROVIDED: 1>]

Redirect the frontend to a new PC.

class coreblocks.frontend.frontend.RollbackTagger

Bases: Elaboratable

Provides rollback_tag field for instructions leaving the Frontend and decides on which instructions a checkpoint should be created.

rollback_tag is used to identify new instructions fetched after each rollback. Instructions from previous rollback are flushed internally in Frontend (and this module), but this is needed to differentiate from instructions that left Frontend earlier.

Requires get_instr and push_instr methods

__init__(gen_params: GenParams) → None

get_instr: REQUIRED: 2>]

push_instr: REQUIRED: 2>]

rollback: PROVIDED: 1>]

coreblocks.frontend.frontend_params module

class coreblocks.frontend.frontend_params.FrontendParams

Bases: object

__init__(gen_params: GenParams)

fb_addr(pc: Value | int | Enum | ValueCastable) → Value

Returns the fetch block address of a given PC.

fb_instr_idx(pc: Value | int | Enum | ValueCastable) → Value

Returns the index of an instruction in a fetch block for a given instruction PC.

pc_from_fb(fb_addr: Value | int | Enum | ValueCastable, fb_instr_idx: int | Value) → Value

For a given fetch block address and an instruction index, returns the instruction’s PC.

coreblocks.frontend.ftq module

class coreblocks.frontend.ftq.FTQReadQueue

Bases: Elaboratable

A memory indexed by FTQ pointer, with random-access writes and an internal read pointer that pops entries in FTQ order.

__init__(gen_params: GenParams, layout: Layout, rollback_ports: int = 0)

class coreblocks.frontend.ftq.FetchTargetQueue

Bases: Elaboratable

Tracks speculative fetch targets in a circular buffer indexed by FTQ pointer. Each entry represents one fetch block: the FTQ allocates an entry per fetch, sends the PC to both the IFU and BPU, and advances the fetch pointer. Entries are freed once the training stream has consumed them; the buffer stalls allocation when full.

__init__(gen_params: GenParams) → None

backend_redirect: PROVIDED: 1>]

Handle a backend misprediction: reset alloc/fetch pointers to commit+1 and redirect the FAU.

bpu_fetch_target: PROVIDED: 1>]

Pass an FTQ entry’s next fetch target to the FAU.

bpu_flush: REQUIRED: 2>]

Flush pending branch prediction requests (called on any redirect).

bpu_prediction_details: PROVIDED: 1>]

Store an FTQ entry’s prediction, predictor metadata, and lookup PC.

bpu_request: REQUIRED: 2>]

Request a branch prediction for the given PC and FTQ pointer.

bpu_update: REQUIRED: 2>]

Train the branch predictor with a resolved branch.

check_stale: PROVIDED: 1>]

Tell whether a fetch request (identified by its FTQ pointer and generation) is stale, i.e. was invalidated by a redirect after it was issued.

commit: PROVIDED: 1>]

Retire an FTQ entry, advancing the commit pointer and freeing the slot.

ifu_request: REQUIRED: 2>]

Issue a fetch request to the instruction fetch unit for the given PC and FTQ pointer.

ifu_writeback: PROVIDED: 1>]

Handle an IFU-detected misprediction/unsafe instruction: flush the BPU and either redirect fetch to a new PC or invalidate the fetch PC, which stalls fetching until the backend resumes it.

jump_target_req: PROVIDED: 1>]

Request the predicted jump target for a given FTQ entry (stub).

jump_target_resp: PROVIDED: 1>]

Return the predicted jump target for a given FTQ entry (stub).

ras_peek: PROVIDED: 1>]

Read the address on top of the return address stack.

ras_predict: PROVIDED: 1>]

Apply a fetch block’s speculative effect on the return address stack and checkpoint it.

read_prediction: PROVIDED: 1>]

Return the branch prediction stored for a given FTQ entry (read by the fetch unit).

resolve: PROVIDED: 1>]

Record branch resolution information for a committed FTQ entry (stub).

stall_guard: REQUIRED: 2>]

Blocks only while the pipeline is stalled (e.g. during a flush).

coreblocks.frontend.stall_controller module

class coreblocks.frontend.stall_controller.StallController

Bases: Elaboratable

The stall controller watches for exceptions raised on the speculative path and stalls the frontend until the backend redirects it to the trap handler (or a rollback invalidates the exception and redirects the frontend itself).

__init__(gen_params: GenParams)

frontend_flush: REQUIRED: 2>]

get_exception_information: REQUIRED: 2>]

Gets information from ExceptionInformationRegister.

stall_guard: PROVIDED: 1>]

A non-exclusive method whose readiness denotes if the frontend is currently stalled.

Module contents