BOOM
Awesome RISC-V

BOOM

RISC-V ecosystem

BOOM is an out-of-order RISC-V core written in Chisel. It can execute instructions in a different order than the program lists them, which keeps more execution units busy. SonicBOOM, its third version, came out in 2020.

Overview

SpecificationValue
ISA supportRV64GC
MicroarchitectureOut-of-order, superscalar; the SonicBOOM evaluation configuration fetches four instructions per cycle and issues up to eight
Performance density6.2 CoreMark/MHz for SonicBOOM (BOOMv3)
Resource footprintASIC-oriented; the project publishes no LUT count
Clock domainSynthesized at 1 GHz on a commercial FinFET process; 1.2 GHz on a 12 nm tape-out

BOOM, the Berkeley Out-of-Order Machine, is a 64-bit RISC-V core written in Chisel, a hardware construction language built on Scala. A core is the part of a chip that executes instructions. An out-of-order core can execute instructions in a different order than the program lists them. When one instruction waits for data from memory, later instructions that do not depend on it go ahead, and more of the core's execution units stay busy.

It implements the RV64GC instruction set, supporting 64-bit general-purpose computing, compressed instructions and virtual memory. Its third generation, SonicBOOM, achieves 6.2 CoreMark/MHz, a normalized benchmark score measuring processor performance relative to clock frequency.

Microarchitecture

BOOM microarchitecture showing the front end, rename, issue queues, reorder buffer, load store unit and execution units.
BOOM microarchitecture showing the front end, rename, issue queues, reorder buffer, load store unit and execution units. BOOM documentation (BSD-3-Clause)
The BOOM pipeline from fetch to commit.
The BOOM pipeline from fetch to commit. BOOM documentation (BSD-3-Clause)

BOOM uses out-of-order execution to improve instruction throughput. Its front end fetches instructions and predicts branches, while register renaming eliminates false dependencies. Instructions enter issue queues, where they wait until their operands are available. The reorder buffer preserves program order at retirement, ensuring precise exceptions and architecturally correct execution.

SonicBOOM, the third generation of BOOM, fetches up to four instructions and issues up to eight per cycle. It achieves a reported score of 6.2 CoreMark/MHz, although benchmark results vary across configurations.

PartBOOM
ExecutionOut of order, superscalar
Fetch and issueFour instructions fetched per cycle and up to eight issued in the SonicBOOM evaluation configuration
StructuresRename stage, issue queues, reorder buffer, load store queue
CachesL1 instruction and data caches, shared L2 in Chipyard systems
InterconnectTileLink
Benchmark6.2 CoreMark/MHz for SonicBOOM

Memory and register map

BOOM uses separate instruction and data caches to support instruction fetching and memory access. The core connects to the system's memory hierarchy through TileLink interfaces, and the SoC integration defines the available memory regions and peripheral address ranges. These addresses depend on the system configuration and are documented in the generated device tree.

Reading the map
# on the running system
dtc -I fs -O dts /proc/device-tree | grep -n -E "memory@|serial@|clint@|plic@"

# on a firmware image that carries its device tree
dtc -I dtb -O dts -o soc.dts soc.dtb
grep -n "reg = <" soc.dts
ℹ

A firmware image that includes a device tree blob contains the map the software expects, which can be compared with the running system.

RegionOwner
Boot ROMSystem integration, first instructions after reset
CLINT and PLICInterrupt controllers of the system
UART and other peripheralsSystem peripherals
DRAMBoard memory

Physical implementation

BOOM supports ASIC synthesis and FPGA-based prototyping through FireSim. The SonicBOOM study reported a 1 GHz implementation using a commercial FinFET process and a 12 nm tape-out at 1.2 GHz. FireSim evaluations on AWS F1 boards operated at 30 MHz while simulating a system clocked at 3.2 GHz using the smallboom configuration.

TargetReported figure
ASIC synthesis1 GHz on a commercial FinFET process; 1.2 GHz on 12 nm (SonicBOOM paper)
FPGARuns on AWS F1 through FireSim at 30 MHz using smallboom, modeling a faster system; upstream target >90 MHz
AreaMuch larger than an in-order core, no LUT figure published
Process nodeChosen by whoever builds the chip

Identifying the part

BOOM does not have a universal hardware identifier. To identify it in an existing system, inspect the CPU's ISA and hardware identification registers, then compare the implementation details with the platform documentation. The device tree can reveal the processor configuration, while Chipyard build files and RTL sources can confirm whether the core uses BOOM.

Where it appearsHow to confirm
Chipyard systemsDevice tree compatible strings and memory map
FireSim simulationsPlatform description of the simulated system
Research siliconProject papers and release notes

Disassembly and debugging

BOOM supports RV64GC with the bit-manipulation extension (B), corresponding to the rv64gcb compiler target. Use readelf -A to inspect the binary's required ISA extensions and objdump -d to examine its instructions. Runtime identification CSRs provide information about the processor's supported extensions and implementation.

Tools
riscv64-unknown-elf-readelf -A firmware.elf
riscv64-unknown-elf-objdump -d -M no-aliases firmware.elf
llvm-objdump -d --mattr=+m,+a,+f,+d,+c,+zb* firmware.elf
ItemValue
ISARV64GCB in the default configuration
Compiler flags-march=rv64gc -mabi=lp64d
Debug transportRISC-V Debug 0.13 over JTAG, through the surrounding Chipyard system
Reset addressSet by the system integration
misa (0x301)ISA and enabled extensions
mvendorid (0xF11)JEDEC vendor ID, read-only
marchid (0xF12)microarchitecture ID, read-only
mimpid (0xF13)implementation version, read-only
mhartid (0xF14)hart that runs the code, read-only

History

Christopher Celio started BOOM in the Berkeley Architecture Research group at UC Berkeley and described its design in a 2015 technical report. A second version followed in 2017. Jerry Zhao, Ben Korpan, Abraham Gonzalez and Krste Asanovic presented SonicBOOM, the third version, in 2020.

Where it is used

BOOM is a research core. Its parameters set the pipeline width, the number of execution units and the size of internal queues, which lets researchers measure how each choice affects performance. Users build BOOM systems through Chipyard because the repository holds only the core.

Sources

  1. riscv-boom README
  2. The Berkeley Out-of-Order Machine, UCB/EECS-2015-167
  3. BOOM v2, UCB/EECS-2017-157
  4. SonicBOOM, CARRV 2020
  5. Chipyard documentation
  6. RISC-V Debug Specification