Skip to content

Navigation

Introduction

Page Description
Overview What this project is, the two models it provides, and how the repository is organized.
Installation What to install for what you want to do: the basic tools and the code, then, optionally, Sitar, the cross-toolchain, gdb, and MkDocs.
Getting Started A hands-on walkthrough: build the models, run a first program, view its trace, run the validation suite, compile a program yourself, and debug with gdb.

The Models

What the models contain: the architecture, the configurations, and their components.

Page Description
SPARC V8 Architecture A page-indexed guide into the bundled SPARC V8 manual PDF.
Model Configurations A block-diagram-level summary of each testbench configuration.
Model Components Describes each component in detail: SparcCore, Mmu, Memory, Caches, Devices, the system bus, and the APARA engine.
Peripheral Devices Overview, connection diagram, address map, and interrupt levels for the peripherals below.
Timer Register format, one-shot behavior, and state machine.
Interrupt Controller The shared, multi-thread IRC: one slot per hardware thread, interrupt sources, priority, and inter-processor interrupts.
Serial Device UART register format, baud-rate calculation, and the Tx/Rx state machines.
Scratch-pad 32 words of uncached storage shared by every core, for flags between cores.
Model Components Reference A complete, per-file table of every Sitar module/procedure.

Using the Models

How to write programs for any configuration, set and measure a model, and log and debug a run. These pages apply to every configuration, including the multicore system and the APARA configurations.

Writing Programs

Page Description
Assembly Programs How to write, assemble, and run your own assembly test programs.
C Programs How to write, compile, and run freestanding C test programs.
Cross Compiler The bundled sparc-elf toolchain used to assemble and compile test programs.

Settings and Performance

Page Description
Model Configuration Settings Every structural and timing setting in the model, where to set it, compile time or runtime.
Performance Modeling How to print the model's performance measures with --stats, and the table of what's reported.
Parallel Simulation Running a Sitar model on several host threads: why the result does not change, what a barrier costs, when a parallel run is faster, and a 64-core speedup demonstration.

Logging and Debugging

Page Description
Logging How instruction-trace logging works, compile-time and runtime, and the log viewer.
Examining Core State with GDB A beginner-facing walkthrough of debugging a running model with gdb.
GDB Command Reference The exhaustive reference for every sparc-* gdb command.
Debug Support Internals How gdb support is actually built, for anyone extending debug/sparc.gdb itself.

Validation Suite

Page Description
Validation Suite What's in a test, which suites run on which configuration, how to run them, and how to add a new test.

The multicore system and the APARA engine each have a validation page of their own, in their sections below.

The Multicore System

Several SPARC cores, each with its own caches and MMU, sharing one main memory and one set of devices (the multicore configuration).

Page Description
Overview The system at a glance, a first run, the ways to run a program, and the system's options.
Programming the System The startup file, the core ID, sharing data with and without coherent caches, locks and other synchronization, interrupts on several cores, shared devices, TLB shootdown, and the routines provided.
OpenMP Programs Programs written with real OpenMP pragmas, the runtime behind them, what is supported, and its limits.
Example Programs A parallel array sum and a parallel matrix multiply, explained.
Logging and Debugging Per-core traces, gdb with several cores, statistics, and finding data races.
Execution Model How each model runs several cores, what a cycle means in each, and why results can differ between them.
Model Structure and Assumptions How the cpp_model and the sitar_model are built, the shared bus, its lock and coherence, interrupts, and where the model makes its own assumptions.
Validation Suite The multicore tests, how each core's results are checked, how they were shown able to fail, how to run them, and what they do not cover.
Parallel Simulation Building and running the sitar_model on several host threads, and dividing its modules among them.

The APARA Accelerator

APARA is a vector compute engine designed to work alongside a SPARC processor as an accelerator. These pages cover the engine on its own (apara) and next to the SPARC core (sparc_apara).

Page Description
The APARA Engine Overview of the APARA vector compute engine, and its two configurations.
APARA Instruction Set The engine's state, data types, bundles, and every instruction.
APARA Assembly Language and Tools mcode, the assembler and disassembler, and the file formats.
Writing and Running APARA Programs Running an engine program on its own, and how the pipeline handles hazards.
The APARA C Compiler apcc.py: the C subset, the intrinsics and inline mcode, and running linear algebra programs on the engine.
APARA Timing Model The engine's five-stage pipeline in the Sitar model, and its timing rules and knobs.
The Engine in a System The hardware of sparc_apara. Its components, how they are connected, the address map, the control and DMA units, the interrupt, and the two models.
Programming the System How a SPARC program uses the engine. An example offload explained, the ready-made routines, the setup protocol, and a new program built step by step.
APARA Validation Suite The engine suites and the system suites. What they contain, how to run them on both models, and how to add a test.
APARA Deviations and Findings The model's sources, where it deliberately departs from them, and the open questions (for the model's authors).

More

Page Description
Reference Documents The SPARC manual, the AJIT processor description and the APARA microarchitecture document, in copies kept here.
Development Notes For contributors: repository layout, extending the core, adding tests.
Authors Who built this project, and credits for the adapted validation suite.
License The MIT License this project is released under.