Access Official Technical PDF

Share Summary:LinkedInEmail

Open-source RISC-V FPGA soft cores give automation and embedded-systems teams options for adding programmable processing to FPGA designs. But comparing those options is not straightforward: cores can use different memory interfaces, build systems and configuration methods, and a design that works on one FPGA platform may not transfer easily to another. A common integration and evaluation approach can make the trade-offs clearer before a core is selected for a system.

A study of seven open-source 32-bit RISC-V cores addressed this problem by packaging them as compatible processing elements within the TaPaSCo FPGA system-on-chip framework. The cores were synthesized across multiple Xilinx platforms and benchmarked in hardware. The results show that the RISC-V label alone says little about a core’s FPGA frequency, resource footprint or application-level performance.

Why comparing RISC-V FPGA soft cores is difficult

The RISC-V instruction set architecture defines the instructions and behavior that implementations must support, but it does not prescribe every detail of a processor’s interfaces or internal organization. Designers can therefore make different choices about pipeline depth, memory access, optional extensions and peripheral connections. One core may have separate instruction and data buses; another may share an interface.

Those differences create practical work for engineers evaluating processors. A core’s example project may target a different FPGA board, and its build flow may not match the tools already in use. Porting and debugging each candidate independently takes time and can make comparisons less useful, particularly when the surrounding system differs as well as the processor.

The evaluation selected cores that were open-source or available to researchers, suitable for FPGA implementation, compatible with a recent ISA version, 32-bit, and capable of fitting TaPaSCo’s processing-element interface. The seven selected designs were Flute, Orca, Piccolo, PicoRV32, SweRV, Taiga and VexRiscv. They span different pipeline structures and design priorities, from size-oriented implementations to cores intended for higher performance.

What a common TaPaSCo integration provides

TaPaSCo abstracts parts of FPGA system generation and software interaction. To fit its processing-element model, each RISC-V core was wrapped with hardware to manage program execution and communicate with the host. The controller holds the processor until a program is loaded, starts execution, and signals completion to the host with an interrupt.

Each packaged core has local instruction and data memory. The host can load a program into instruction memory, while data can reside in local memory or, where needed, shared off-chip memory. The study used a Harvard-style local memory arrangement, with separate instruction and data memories. This suited cores with separate buses and helped avoid additional interconnect logic in those paths. PicoRV32, which has a single AXI interface, required an intermediate interconnect.

Putting cores in this shared framework also helps isolate their differences. The same general TaPaSCo API can be used to launch programs and collect results, rather than relying on a distinct host interface for every processor. However, integration still required attention to bus addressing, HDL compatibility, packaging conventions and configuration behavior. Some cores needed Verilog wrappers or code adjustments to work with the toolchain used in the study.

Performance and FPGA resource trade-offs

The hardware evaluation covered four Xilinx platforms: the VC709, AU250, ZCU102 and PYNQ. It measured maximum frequency and resource use, including logic, registers, block RAM and DSPs. The reported resource figures covered the processing element, controller and local memory, rather than the complete TaPaSCo infrastructure.

Frequency varied substantially among the evaluated cores. The slowest designs ran below 100 MHz on large UltraScale+ devices, while FPGA-oriented implementations exceeded 500 MHz. PicoRV32 and VexRiscv were among the fastest by frequency in the reported results. Frequency alone, however, does not establish which processor will perform best: pipeline design and the work completed per cycle also matter.

Area use also differed. SweRV had the largest resource footprint in the comparison, consistent with its more complex pipeline. Orca had the smallest footprint, with VexRiscv, Taiga and PicoRV32 also using relatively few resources. This matters when a design needs several processing elements: a smaller core may be attractive for parallel deployment, although its clock rate and benchmark performance must be considered alongside its area.

Benchmarks show why workload matters

The processors ran Dhrystone, CoreMark and Embench. Measurements were taken on hardware, and benchmark execution time excluded data-transfer time. For these tests, benchmark data was held in local instruction and data memories, so the results did not depend on off-chip memory performance.

Taiga led the reported CoreMark results at 2.53 CoreMark/MHz, followed by Orca at 1.4, VexRiscv at 1.2, and Piccolo and Flute at 1.0. PicoRV32 had the lowest relative performance in this benchmark. Taiga also led the Embench comparison, with Orca and VexRiscv following. The Dhrystone results likewise favored Taiga, but the study cautions that compiler choices and optimization can strongly affect this older benchmark.

These figures are useful for comparing the tested configurations within the study, not as universal ratings. The cores were configured without caches for comparability, and the software toolchain and memory setup shaped the results. A different configuration can change performance: for example, the study notes that SweRV can benefit substantially from executing from its Instruction Closely Coupled Memory, although that requires a different program-loading approach.

Choosing a core for an automation design

For engineers and system integrators, the practical lesson is to evaluate a soft processor against the intended system and workload rather than selecting by ISA or clock frequency alone. Consider:

  • Interface compatibility: Check how the core connects to local and shared memory, peripherals and host control.
  • FPGA fit: Compare logic, register, block RAM and DSP use on the target platform.
  • Workload performance: Use benchmarks relevant to the application, and interpret normalized scores alongside absolute frequency.
  • Toolflow effort: Account for HDL support, build requirements, configuration reliability and the work needed to package the core.

A common framework makes these comparisons more systematic, but it does not remove the need to validate a candidate in the intended design. For industrial automation teams exploring embedded control or FPGA-based processing, the study’s central implication is straightforward: open-source RISC-V cores span a wide performance and resource range. A consistent evaluation can narrow the field, while final selection should reflect the application, integration constraints and memory architecture.

Access Official Technical PDF

About The Author