BOOM
RISC-V ecosystemBOOM 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
| Specification | Value |
|---|---|
| ISA support | RV64GC |
| Microarchitecture | Out-of-order, superscalar; the SonicBOOM evaluation configuration fetches four instructions per cycle and issues up to eight |
| Performance density | 6.2 CoreMark/MHz for SonicBOOM (BOOMv3) |
| Resource footprint | ASIC-oriented; the project publishes no LUT count |
| Clock domain | Synthesized 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 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.
| Part | BOOM |
|---|---|
| Execution | Out of order, superscalar |
| Fetch and issue | Four instructions fetched per cycle and up to eight issued in the SonicBOOM evaluation configuration |
| Structures | Rename stage, issue queues, reorder buffer, load store queue |
| Caches | L1 instruction and data caches, shared L2 in Chipyard systems |
| Interconnect | TileLink |
| Benchmark | 6.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.
# 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.dtsA firmware image that includes a device tree blob contains the map the software expects, which can be compared with the running system.
| Region | Owner |
|---|---|
| Boot ROM | System integration, first instructions after reset |
| CLINT and PLIC | Interrupt controllers of the system |
| UART and other peripherals | System peripherals |
| DRAM | Board 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.
| Target | Reported figure |
|---|---|
| ASIC synthesis | 1 GHz on a commercial FinFET process; 1.2 GHz on 12 nm (SonicBOOM paper) |
| FPGA | Runs on AWS F1 through FireSim at 30 MHz using smallboom, modeling a faster system; upstream target >90 MHz |
| Area | Much larger than an in-order core, no LUT figure published |
| Process node | Chosen 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 appears | How to confirm |
|---|---|
| Chipyard systems | Device tree compatible strings and memory map |
| FireSim simulations | Platform description of the simulated system |
| Research silicon | Project 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.
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| Item | Value |
|---|---|
| ISA | RV64GCB in the default configuration |
| Compiler flags | -march=rv64gc -mabi=lp64d |
| Debug transport | RISC-V Debug 0.13 over JTAG, through the surrounding Chipyard system |
| Reset address | Set 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.