Skip to content

Model Components Reference

A complete, per-file index of every Sitar design unit (module or procedure) in this repo. For each one it lists what it is, where it lives, what plain C++ class (if any) it wraps, what design unit embeds it, and its one-line description. See Model Components for the narrative overview this table indexes. See each file's own header comment for the full detail behind its one-line description here.

There is one table per configuration, listed top-down: the root module first, then its children in the order each parent instantiates them, depth-first. A design unit shared by several configurations (everything under sitar_component_models/) appears in the table of each configuration that uses it. From core_mmu_devices on, each table lists only what differs from the configuration it builds on.

  • Scope
    common means the file lives in model/sitar_component_models/ and is translated into every configuration's build, whether or not that configuration actually instantiates it. See that folder's own build-script comment. A configuration's name (core_only, core_mmu, ...) means the file lives under that configuration's own system_models/<config>/sitar_model/src/.

  • Parent
    Names what instantiates this row within the current table's configuration, and how many instances. Reads "None (root)" for Top.

core_only

Design unit File Scope Embedded C++ class Parent Description
Top (module) Top.sitar core_only None None (root) The required root module for the core_only build. It just instantiates Core.
Core (module) Core.sitar core_only None Top Wires sparcThread and mainMemory : VirtualMainMemory as two parallel procedures sharing a request/response handshake.
SparcThread (procedure) SparcThread.sitar common SparcCore Core (1 instance: sparcThread) The SPARC V8 fetch-decode-execute-trap state machine. Owns 5 VirtualMainMemoryInterface instances for ifetch, load, store, atomic, and flush.
VirtualMainMemoryInterface (procedure) VirtualMainMemoryInterface.sitar common None SparcThread (5 instances: ifetchProcedure, memReadProcedure, memWriteProcedure, atomicLoadStoreProcedure, flushProcedure) Blocking, VM-shaped (VirtualMemoryRequest/Response) memory-access interface. One run per access. Reused across calls.
VirtualMainMemory (procedure) VirtualMainMemory.sitar common MemCore Core (1 instance: mainMemory) Persistent VM-shaped memory model wrapping MemCore. core_only's terminal memory node. No MMU sits downstream of it.

core_mmu

Design unit File Scope Embedded C++ class Parent Description
Top (module) Top.sitar core_mmu None None (root) The required root module for the core_mmu build. It just instantiates System.
System (module) System.sitar core_mmu None Top Assembles Core and PhysicalMainMemory as sibling submodules, connected by two nets. Owns the consolidated latency-knob block for this configuration.
Core (module) Core.sitar core_mmu None System (1 instance: core) Wires sparcThread and mmu as two parallel procedures sharing a request/response handshake. Exposes two ports so mmu can reach physical memory over nets.
SparcThread (procedure) SparcThread.sitar common SparcCore Core (1 instance: sparcThread) The SPARC V8 fetch-decode-execute-trap state machine. Owns 5 VirtualMainMemoryInterface instances for ifetch, load, store, atomic, and flush.
VirtualMainMemoryInterface (procedure) VirtualMainMemoryInterface.sitar common None SparcThread (5 instances: ifetchProcedure, memReadProcedure, memWriteProcedure, atomicLoadStoreProcedure, flushProcedure) Blocking, VM-shaped (VirtualMemoryRequest/Response) memory-access interface. One run per access. Reused across calls.
Mmu (procedure) Mmu.sitar common MmuCore Core (1 instance: mmu) The Sitar timing model for the MMU. Sits between SparcThread and physical memory. Drives MmuCore's step-primitives through real, timed physical accesses.
PhysicalMainMemoryInterface (procedure) PhysicalMainMemoryInterface.sitar common None Mmu (2 instances: phyMemReadProcedure, phyMemWriteProcedure) Mmu's own physical-access transaction procedure. Nests one PushAToken/PullAToken pair to reach PhysicalMainMemory over nets.
PullAToken (procedure) PullAToken.sitar common None PhysicalMainMemoryInterface (1 instance: getPhyMemResponse) and PhysicalMainMemory (1 instance: getRequest) Generic single-token consumer, parameterized by width. Retry-pulls from an inport until it receives exactly one token.
PushAToken (procedure) PushAToken.sitar common None PhysicalMainMemoryInterface (1 instance: sendPhyMemRequest) and PhysicalMainMemory (1 instance: sendResponse) Generic single-token producer, parameterized by width. Retry-pushes one token onto an outport until there's room.
PhysicalMainMemory (module) PhysicalMainMemory.sitar common MainMemory System (1 instance: mainMemory) Persistent PM-shaped memory model wrapping MainMemory. core_mmu's terminal memory node, below the MMU, reached over nets rather than a procedure handshake.

core_mmu_devices

Every core_mmu design unit above appears here too, except that this configuration's own System and Core replace core_mmu's, and three more join them.

Design unit File Scope Embedded C++ class Parent Description
System (module) System.sitar core_mmu_devices None Top Assembles Core, SystemBridge, PhysicalMainMemory, and PeripheralDevices, connected by seven nets. Owns the consolidated latency-knob block for this configuration.
Core (module) Core.sitar core_mmu_devices None System (1 instance: core) core_mmu's Core, plus an inport for the interrupt level and a branch that polls it every cycle and drives the core's IRL pins.
SystemBridge (module) SystemBridge.sitar common None (uses SystemAddressMap.h) System (1 instance: bridge) The physical bus below the MMU. Routes each request to main memory or to the devices by address, one transaction at a time.
PeripheralDevices (module) PeripheralDevices.sitar common PeripheralDevicesCore System (1 instance: devices) The shared Timer, Serial, Interrupt Controller and scratch-pad. Ticks them once per cycle, services register accesses, sends each core its interrupt level.

core_l1cache_mmu_devices

Every core_mmu_devices design unit appears here too, except that this configuration's own System and Core replace those, and one more joins them.

Design unit File Scope Embedded C++ class Parent Description
System (module) System.sitar core_l1cache_mmu_devices None Top The same four modules and seven nets as core_mmu_devices, plus the cache knobs in the consolidated knob block.
Core (module) Core.sitar core_l1cache_mmu_devices None System (1 instance: core) core_mmu_devices' Core, with caches between sparcThread and mmu.
L1Caches (procedure) L1Caches.sitar common L1CachesCore Core (1 instance: caches) The split L1 caches. Serves sparcThread's accesses, reaches mmu only on a miss or a forwarded access.

multicore

Every core_l1cache_mmu_devices design unit appears here too, except that this configuration's own System and Core replace those, and CoherentBridge replaces SystemBridge. See Model Structure and Assumptions.

Design unit File Scope Embedded C++ class Parent Description
System (module) System.sitar multicore None Top Assembles NUM_CORES Cores, CoherentBridge, PhysicalMainMemory, and PeripheralDevices. Stops the simulation once every running core has halted. Owns the NUM_CORES knob and the consolidated latency-knob block.
Core (module) Core.sitar multicore None System (NUM_CORES instances: cores[i]) core_l1cache_mmu_devices' Core, except that a halted core does not stop the simulation.
CoherentBridge (module) CoherentBridge.sitar common None (uses SystemAddressMap.h) System (1 instance: bridge) The physical bus below the cores' MMUs. Grants the cores round robin and routes each request to main memory or to the devices, one transaction at a time. Holds the bus lock that makes LDSTUB and SWAP atomic across cores, and with --coherent sends invalidates to the other cores.

apara

The standalone engine: none of the SPARC design units above take part.

Design unit File Scope Embedded C++ class Parent Description
Top (module) Top.sitar apara None None (root) The root module for the apara build. Instantiates one AparaEngine, stops the simulation once every started thread has stopped, and holds the engine's timing knobs.
AparaEngine (module) AparaEngine.sitar common None Top (1 instance: engine) The engine's five-stage pipeline: one module per stage, joined by nets with the hardware's channel depths.
AparaFetch (module) AparaFetch.sitar common AparaTiming.h (BranchTargetBuffer) AparaEngine (1 instance: fetch) The FETCH stage. Keeps each thread's fetch PC and the branch target buffer, picks a thread round robin, and sends the bundles of its IMEM line to DECODE, one per cycle, each with a predicted next PC.
AparaDecode (module) AparaDecode.sitar common None AparaEngine (1 instance: decode) The DECODE stage. Finds a bundle's registers, latency, and divider use, and passes it on its thread's channel to REGFILE.
AparaRegfile (module) AparaRegfile.sitar common None AparaEngine (1 instance: regfile) The REGFILE stage. Holds one bundle per thread, issues one per cycle whose registers are unlocked while a token is free, and releases locks and tokens as results come back from EXEC. Also counts, independently of the locks, the bundles issued while a register they read still has a write outstanding (the hazard count), and has the interlock knob that turns the locks off for that check.
AparaExec (module) AparaExec.sitar common AparaCore AparaEngine (1 instance: exec) The EXEC stage, and the owner of the engine's functional state. Executes each bundle and holds it for its latency, and checks that the registers it used were within its lock masks. In a system, also serves the host side's requests and sends the engine's loads and stores that leave its data memory.
AparaWriteback (module) AparaWriteback.sitar common None AparaEngine (1 instance: writeback) The WRITEBACK stage. Sends FETCH a PC correction for a mispredicted bundle, and a notice when a thread stops.

sparc_apara

Every core_l1cache_mmu_devices design unit appears here too, except that this configuration's own System and Core replace those, and SystemInterconnect replaces SystemBridge. The engine's design units are those of apara above (except its Top), plus AparaHost.

Design unit File Scope Embedded C++ class Parent Description
System (module) System.sitar sparc_apara None Top Assembles Core, SystemInterconnect, PhysicalMainMemory, PeripheralDevices, AparaEngine, and AparaHost. Owns the consolidated latency-knob block for this configuration, the engine's knobs included.
Core (module) Core.sitar sparc_apara None System (1 instance: core) The same as core_l1cache_mmu_devices' Core.
SystemInterconnect (module) SystemInterconnect.sitar common None (uses SystemAddressMap.h) System (1 instance: interconnect) The physical bus with two masters, the core and the engine's host side, taken round robin. Routes each request to main memory, the devices, or the engine's windows, one transaction at a time.
AparaEngine (module) AparaEngine.sitar common None System (1 instance: engine) As in apara.
AparaHost (module) AparaHost.sitar common AparaControlCore, AparaDmaCore System (1 instance: host) The engine's host side: its control unit and DMA unit. Serves the SPARC's accesses to the engine's three windows, carries out their commands through engine.exec, and sends DMA transfers and the engine's outside loads and stores onto the bus as its second master. Drives the engine's interrupt.

Notes

  • Module vs. procedure
    Top, System, Core, PhysicalMainMemory, SystemBridge, SystemInterconnect, CoherentBridge, PeripheralDevices, and every Apara* design unit are modules. Every other row above is a procedure. See the sibling sitar repo's own documentation for the general module/procedure distinction, and System.sitar's own header comment for how it plays out in core_mmu specifically.

  • Reading "None" in the C++ class column
    This applies to every request/response-only or token-only procedure (VirtualMainMemoryInterface, PhysicalMainMemoryInterface, PullAToken, PushAToken), to the three purely structural modules (Top, System, Core), to the buses (SystemBridge, SystemInterconnect), and to the APARA pipeline stages that only move bundles (AparaEngine, AparaDecode, AparaRegfile, AparaWriteback). None of these hold a functional-model class instance themselves.