Access Official Technical PDF

Share Summary:LinkedInEmail

Transprecision computing addresses a practical challenge in embedded and high-performance systems: not every calculation needs the same numerical precision. Matching floating-point (FP) formats to an application’s requirements can help reduce the energy cost of computation while maintaining the precision needed for a task. FPnew, an open-source transprecision floating-point unit (TP-FPU), demonstrates how processor hardware can support this approach across multiple formats and operation types.

Designed as configurable SystemVerilog hardware, FPnew supports standard and custom floating-point formats, scalar and SIMD operations, and integration with RISC-V processor cores. Its architecture offers useful lessons for engineers considering how to make numerical workloads more adaptable without relying exclusively on fixed-width arithmetic.

Why transprecision computing matters

Traditional processor implementations commonly focus on a small set of floating-point formats, such as single and double precision. But workloads vary: some calculations require a wide dynamic range and high precision, while others can use narrower representations. Machine learning is one driver of interest in additional formats, and precision flexibility is relevant across computing systems, from high-performance platforms to low-power embedded devices.

Fixed-point arithmetic can be efficient in some cases, but adopting it typically requires application-specific decisions about numerical range and precision. Floating-point arithmetic provides a more general representation, with features such as rounding modes, gradual underflow, and representations for infinity. Transprecision computing builds on that flexibility by allowing the format and performance of computation to be adjusted to application needs.

The important design consideration is not simply adding smaller formats. Hardware must also provide the operations, conversions, and software support needed to use them effectively. Without those elements, available precision options can be difficult to apply consistently across a workload.

FPnew: a configurable floating-point unit

FPnew is designed to support multiple formats within a single configurable unit. Its implementations include IEEE 754 double precision (FP64), single precision (FP32), and half precision (FP16), as well as bfloat16-like FP16alt and a custom 8-bit FP8 format. The architecture can be configured for other binary formats following IEEE 754 principles, subject to the design’s parameters.

The unit organizes operations into four independent groups:

  • ADDMUL: addition, multiplication, and fused multiply-add (FMA).
  • DIVSQRT: division and square root.
  • COMP: comparisons and bit-manipulation operations.
  • CONV: conversions between floating-point formats and between floating-point and integer values.

This separation allows the hardware to silence unused operation paths through clock and datapath gating. Each format can also be implemented in a parallel slice, with dedicated hardware, or in a merged slice that shares hardware across formats. Parallel slices offer more scope to tune format-specific timing and latency; merged slices can reduce area, but may involve energy or latency overhead when narrower formats use a larger shared datapath.

SIMD and format conversion support

FPnew can pack multiple narrow values into a wider datapath for single instruction, multiple data (SIMD) execution. For example, a 64-bit datapath can support vectors containing multiple narrower floating-point elements. The number and width of lanes depend on the selected formats and whether a slice is parallel or merged.

SIMD is valuable only when data can move between formats and lanes in a usable way. FPnew therefore includes vector conversions and data-packing operations. Its cast-and-pack functionality can convert two scalar operands and place them into a vector, while vector conversion instructions address cases where source and destination vector lengths differ. These capabilities support runtime precision adjustment and reduce the need to handle every packing step as a separate operation.

The architecture also supports fused multiply-add, which computes a multiplication and addition with one final rounding step. In merged slices, a multi-format FMA can multiply operands in one format and accumulate into a destination format. This enables mixed-format operations within a single instruction, where supported by the processor’s instruction set.

Integrating transprecision into RISC-V processors

Hardware flexibility needs a software interface. The FPnew work extends the RISC-V instruction set architecture with operations for additional formats, vector operations, and auxiliary functions. The associated compiler support allows custom formats to be represented in C and C++ programs, while programmers can use compiler-enabled vectorization or intrinsic functions for more direct control.

FPnew was integrated into both the 32-bit RI5CY embedded core and the 64-bit Ariane application-class core. In the RI5CY case study, mixed-precision execution achieved a reported 1.67× speedup over an FP32 baseline while maintaining end-to-end result precision, with processor energy for the workload reduced by 37%. These results illustrate how format flexibility can affect a complete workload, rather than only the energy of an individual arithmetic operation.

The Ariane implementation was fabricated in GlobalFoundries 22FDX technology and measured across a wide voltage range. The reported unit supported five formats on scalar data or SIMD vectors, with measured energy efficiency ranging from 178 Gflop/s/W on FP64 to 2.95 Tflop/s/W on 8-bit mini-floats. These figures apply to the reported implementation and measurement conditions; they are not a general performance guarantee for other designs or workloads.

Design trade-offs for engineering teams

For system architects and integrators, FPnew highlights several decisions that shape a transprecision FPU:

  • Format selection: Choose formats based on the numerical needs of target workloads, including any custom formats required.
  • Parallel or merged datapaths: Balance area and resource sharing against format-specific latency and energy behavior.
  • Pipeline configuration: Set operation and format pipeline depths to suit the processor and implementation technology.
  • Software enablement: Provide instruction-set, compiler, and programming support so applications can use narrower formats and conversions.
  • Data movement: Consider vector packing and conversion alongside arithmetic, since changing precision often involves rearranging as well as computing on data.

Energy proportionality depends on implementation choices. FPnew’s measured results show that dedicated format slices can help reduce the energy of smaller-format scalar and vector arithmetic, while shared conversion hardware may scale less directly. Evaluating a design therefore requires attention to the full operation mix, not just the nominal width of its operands.

Conclusion

Transprecision computing offers a way to align floating-point hardware with the numerical demands of each workload. FPnew demonstrates how a configurable FPU can combine multiple formats, SIMD execution, conversion support, and RISC-V software integration. For industrial and embedded system designers, the practical takeaway is to evaluate precision as an architectural choice: the right formats and datapath organization depend on workload accuracy, throughput, energy, and integration requirements.

Access Official Technical PDF

About The Author