Abstract
This paper introduces Ara (VU1.0), the first open-source hardware implementation of the ratified RISC-V Vector (RVV) 1.0 specification. Developed by researchers at ETH Zurich and the University of Bologna, Ara demonstrates that the frozen RVV 1.0 standard can be implemented with high efficiency, outperforming previous designs based on older draft versions of the ISA. By addressing the micro-architectural complexities of the v1.0 specification—such as contiguous register file mapping and dynamic element width changes—the design achieves over 98% FPU utilization and 37.1 DP-GFLOPS/W efficiency in 22nm technology. This work proves that open-source vector processors can compete with proprietary high-performance designs in both performance and area efficiency.
Introduction
Vector computing, once the exclusive domain of supercomputers like Fujitsu’s Fugaku, is increasingly vital for modern mobile and edge computing workloads. While proprietary solutions like Arm’s SVE2 dominate the market, the RISC-V Vector (RVV) extension offers an open-standard alternative. However, the transition from early drafts (v0.5) to the ratified v1.0 specification introduced significant micro-architectural hurdles. Ara (VU1.0) represents a milestone in the RISC-V ecosystem as the first open-source implementation to successfully navigate these challenges while delivering state-of-the-art performance.
Architectural Challenges and Solutions
The RVV 1.0 specification requires the Vector Register File (VRF) to appear as a contiguous entity to software. This requirement conflicts with the "lane-based" hardware approach typically used to scale performance, where data is distributed across parallel processing units. Furthermore, the specification allows software to change Effective Element Widths (EEW) at runtime (e.g., switching from 32-bit to 64-bit floats), which can "scramble" data mapping across physical hardware lanes.
To address these issues, Ara utilizes several key architectural innovations:
- Lane-Based Design: The vector unit is partitioned into parallel lanes (scalable to 4, 16, or more), each containing a slice of the VRF and functional units (ALU, FPU).
- Shuffle/Deshuffle Logic: To maintain a contiguous memory view while using banked lanes, the authors implemented byte-level multiplexers that remap data as it moves between memory and the VRF.
- The "Reshuffle" Operation: When a program changes the EEW, the hardware automatically injects a micro-operation to physically move data between lanes, ensuring that tail elements of vectors remain uncorrupted.
- Dedicated Mask Unit: Since RVV 1.0 allows any register to be used as a mask, a specialized unit was developed to fetch and unpack mask bits efficiently across all lanes.
- Lightweight Coherency: Ara is coupled with a CVA6 (formerly Ariane) 64-bit scalar core. Instead of complex cache-coherency protocols, the system uses a write-through L1 cache for the scalar core and a hardware mechanism to invalidate scalar cache lines during vector stores.
Evaluation and Methodology
The design was evaluated using standard high-performance computing (HPC) kernels, including double-precision floating-point matrix multiplication (fmatmul), 2D convolution (fconv2d), and dot products to test the multi-step reduction engine. The hardware was synthesized and "placed-and-routed" using GLOBALFOUNDRIES 22FDX (22nm FD-SOI) technology to obtain realistic Power, Performance, and Area (PPA) metrics.
Key Insights and Results
Efficiency and Performance
Ara achieves a peak performance of 1.34 GHz under typical conditions. On matrix multiplication kernels, it demonstrates a remarkable >98.5% FPU utilization. In terms of energy efficiency, the design delivers 37.1 DP-GFLOPS/W, making it highly competitive with both academic and industrial vector engines. Furthermore, the new 3-step reduction engine (intra-lane, inter-lane, and SIMD) provides up to a 380x speedup over performing reductions on the scalar core alone.
The Impact of the v1.0 Specification
Contrary to expectations that a more complex specification would increase hardware overhead, moving to v1.0 allowed for a 15% area reduction compared to the v0.5 design. This is primarily due to the v1.0 "monomorphic" encoding, which uses specific instructions for specific types, simplifying the control logic compared to the polymorphic approach used in earlier drafts.
System Bottlenecks
The study highlights that as vector units scale, the scalar core becomes a primary bottleneck. By increasing the scalar core's D-cache line size and AXI bus width to 512-bit, the researchers achieved a 1.54x speedup for medium-sized vector operations. Additionally, the design demonstrates high "useful" power consumption; lanes consume over 80% of total power, while control logic remains under 12%, indicating a highly efficient distribution of resources.
Limitations and Future Work
While Ara excels in high-throughput scenarios, it faces challenges with short vector performance. The current design does not implement a "barber-pole" VRF layout, leading to bank conflicts when processing very short vectors. Additionally, certain specialized instructions (e.g., vfirst, viota) and fixed-point arithmetic are currently emulated or omitted. Future iterations may explore renaming stages to decouple source and destination registers, helping to hide the latency of reshuffle operations as lane counts scale further.
Conclusion
Ara (VU1.0) proves that the RISC-V Vector 1.0 specification is not only implementable but also highly efficient for high-performance computing. By providing an open-source, silicon-proven design that achieves 37.1 DP-GFLOPS/W, this work paves the way for a new era of open-source hardware in the supercomputing and mobile sectors.
Source Code: The project is open-source and available at https://github.com/pulp-platform/ara.
Summary updated