Access Official Technical PDF

Share Summary:LinkedInEmail

RISC-V open source hardware offers an alternative to relying exclusively on established, proprietary processor architectures. For industrial automation and other data-intensive applications, the appeal is not simply a different instruction set. It is the opportunity to develop processor designs, software and system interfaces collaboratively, with choices suited to particular workloads. The approach described here spans embedded cores, security, virtualization, compiler development and cache-coherent interconnects.

Why RISC-V open source hardware matters

As compute requirements expand, general-purpose processing can be a poor fit for every task. A clean, open instruction set architecture (ISA) gives hardware designers a shared foundation for creating and adapting processor implementations. RISC-V is an open ISA, while open-source hardware designs and software tools can help participants build and test implementations around it.

This distinction matters: the ISA defines the instructions software can use, while a processor core is a particular hardware implementation of that ISA. An open, collaborative ecosystem can support contributions across both hardware and software, from low-level firmware through operating systems and applications. For system designers, this wider body of work is important because a processor needs more than an instruction set to become practical in a complete system.

Processor cores for different workloads

The SweRV core family illustrates how RISC-V implementations can target different requirements. SweRV Core EH1, released as an open-source design through CHIPS Alliance in 2019, is a two-way superscalar, nine-stage, mostly in-order core based on the RV32IMC instruction set. It was designed for datapath controller applications, including NAND flash controllers.

SweRV Core EH2 builds on EH1 by adding two hardware threads. It maintains much of EH1’s pipeline while providing separate architectural register state and additional microarchitectural resources for the threads. Software can run two RISC-V threads simultaneously. The brief reports a simulated combined CoreMark result of 6.3 CM/MHz for dual-thread operation. It also notes that multithreading can be useful when code includes numerous high-latency I/O operations. The design goal is to improve compute density without simply duplicating the entire core.

At the other end of the range, SweRV Core EL2 is a four-stage, single-issue core optimized for performance relative to power. It is intended for embedded SoC functions such as state-machine sequencing and waveform generation. Its reported simulated CoreMark result is 3.6 CM/MHz. These examples show why core selection should follow the workload: controller datapaths, embedded sequencing and concurrent I/O-heavy code do not necessarily require the same processor architecture.

Security and ISA development

Open Titan is a RISC-V-based silicon root of trust being developed under the LowRISC banner, with Western Digital contributing hardware IP, software and firmware work. A root of trust can be integrated into a system-on-chip to provide a foundation for security functions. The brief identifies a storage-device controller as one intended use case and describes elements including a security processor, cryptographic components, key storage and an entropy source.

ISA details also affect the feasibility of larger systems. RISC-V’s load-reserve/store-conditional (LR/SC) mechanism supports synchronization between threads. The brief describes work to address forward-progress behavior that was difficult to implement and scaled poorly in some applications. The updated specification was intended to make the behavior more like that of other architectures and simplify implementation in many-core systems. For designers, this illustrates how collaborative ISA refinement can address implementation challenges beyond the core itself.

Building the software and development ecosystem

Hardware support depends on a working software stack: boot loaders, firmware, operating systems, development tools and applications. Contributions to projects such as the Linux kernel, U-Boot and OpenSBI help establish this foundation and support Linux distributions on RISC-V hardware.

Virtualization is another part of that ecosystem. Work on RISC-V hypervisor extension support in QEMU and the Linux kernel enabled testing of KVM guests with hardware acceleration. A usable virtualized environment gives hardware vendors a way to validate implementations and gives software teams a platform for development. Compiler quality is also consequential. The brief notes that GCC-generated RISC-V code density lagged other ISAs at the time of its analysis, and describes upstream compiler improvements, optimization-flag work and link-time optimization (LTO). In its reported analysis, LTO reduced the original code size by approximately 20%; that result is specific to the work described, not a universal guarantee.

Connecting processors, memory and accelerators

As systems combine CPUs, FPGAs, GPUs and machine-learning accelerators, sharing data consistently becomes a design challenge. OmniXtend is described as an open cache-coherence protocol that carries coherence messages over an Ethernet-compatible fabric. It builds on TileLink and is intended to extend cache-coherent memory sharing beyond a single processor chip.

In the described architecture, programmable Ethernet switches can support communication among processor caches, memory controllers and accelerators. The proposal emphasizes an open interface and the ability to update dataplane behavior without requiring new system software or ASICs for every protocol improvement. For automation and embedded-system architects evaluating heterogeneous compute, the broader point is that processor choice, memory access and interconnect design need to be considered together.

Practical implications for system designers

RISC-V is best evaluated as an ecosystem rather than as a processor specification in isolation. Engineering teams should consider:

  • Workload fit: Match core architecture and threading to the application’s processing and I/O behavior.
  • Software readiness: Assess the availability of toolchains, boot components, operating-system support and virtualization tools required by the system.
  • Security needs: Determine how a root of trust and related hardware and firmware components fit into the SoC design.
  • System scaling: Consider how processors, accelerators and memory will exchange coherent data as the architecture grows.

Open designs and shared development can broaden the options available to technical teams, but they do not remove the need to validate an implementation against its specific requirements. The practical value of RISC-V comes from aligning the ISA, processor core, software stack, security architecture and interconnect. For industrial and embedded designers facing varied compute demands, that system-level perspective is essential to deciding where an open architecture can provide a suitable foundation.

Access Official Technical PDF

About The Author