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
commonmeans the file lives inmodel/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 ownsystem_models/<config>/sitar_model/src/. -
Parent
Names what instantiates this row within the current table's configuration, and how many instances. Reads "None (root)" forTop.
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 everyApara*design unit aremodules. Every other row above is aprocedure. See the siblingsitarrepo's own documentation for the general module/procedure distinction, andSystem.sitar's own header comment for how it plays out incore_mmuspecifically. -
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.