oprecomp / floatx

Header-only C++ library for low precision floating point type emulation.

OPRECOMP

This is the Open Transprecision Computing project, a joint venture between IBM, ETH, CEA, UNIPG, UNIBO, CINECA, UJI, QUB, GWT, and TUKL.

OPRECOMP is a 4-year research project funded under the EU Framework Horizon 2020 – Re Program Future and Emerging Technologies (FET) Proactive Initiative: emerging themes and communities.

Contents

This is the main repository of the OPRECOMP project. Individual deliverables and development is performed in separate repositories, as follows:

• oprecomp/micro-benchmarks: A collection of benchmarks used throughout the project to assess the impact of transprecision techniques on a broad range of application fields.
• oprecomp/FloatX: Header-only C++ library for low precision floating point type emulation.
• oprecomp/flexfloat and oprecomp/flexfloat-benchmarks: C library for the emulation of reduced-precision floating point types
• oprecomp/HLS_BLSTM: The community version of HLS_BLSTM (A BLSTM FPGA accelerator of an OCR appilcation, using CAPI/SNAP)
• oprecomp/DRAMSpec: A DRAM Current and Timing Generator
• oprecomp/RRAMSpec: An RRAM Area, Energy and Timing Generator
• oprecomp/fp-soft: Floating point implementation of multiplication and addition for processor with variable mantissa adaptation.
• oprecomp/StaticFPTuner: A python module for statically tuning the precision of floating point variables.
• oprecomp/kwpilot-doc: Documentation and tutorials for OPRECOMP kwpilot demonstrator.
• oprecomp/oc-accel-tp: OpenCAPI Acceleration Framework: develop an accelerator with OpenCAPI technology.
• oprecomp/DDR4_controller: A DDR4 memory controller.
• pulp-platform/fpnew: Configurable Floating-Point Unit with Transprecision Capabilities
• DRAMSys 4.0: a flexible DRAM subsystem design space exploration framework based on SystemC TLM-2.0
• DynIR: Header-only C++ library and source code for iterative refinement using dynamic precision out of single, double and double-double precision.

Abstract

Guaranteed numerical precision of each elementary step in a complex computation has been the mainstay of traditional computing systems for many years. This era, fueled by Moore's law and the constant exponential improvement in computing efficiency, is at its twilight: from tiny nodes of the Internet-of-Things, to large HPC computing centers, sub-picoJoule/operation energy efficiency is essential for practical realizations. To overcome the “power wall”, a shift from traditional computing paradigms is now mandatory.

OPRECOMP aims at demolishing the ultra-conservative “precise” computing abstraction and replacing it with a more flexible and efficient one, namely transprecision computing. OPRECOMP will investigate the theoretical and practical understanding of the energy efficiency boost obtainable when accuracy requirements on data being processed, stored and communicated can be lifted for intermediate calculations. While approximate computing approaches have been used before, in OPRECOMP for the first time ever, a complete framework for transprecision computing, covering devices, circuits, software tools, and algorithms, along with the mathematical theory and physical foundations of the ideas will be developed that not only will provide error bounds with respect to full precision results, but also will enable major energy efficiency improvements even when there is no freedom to relax end-to-end application quality-of-results.

The mission of OPRECOMP is to demonstrate using physical demonstrators that this idea holds in a huge range of application scenarios in the domains of IoT, Big Data Analytics, Deep Learning, and HPC simulations: from the sub-milliWatt to the MegaWatt range, spanning nine orders of magnitude. In view of industrial exploitation, we will prove the quality and reliability and demonstrate that transprecision computing is the way to think about future systems.

Contact

Project Management Office

Cristiano Malossi
IBM Research - Zurich
Research Staff Member
[email protected]
[phone]

Sara Pittaluga
IBM Research – Zurich
Business Development & Relations
European Projects Specialist
[email protected]
[phone]

Repository and Software Management

Fabian Schuiki
ETH Zurich
[email protected]

Florian Scheidegger
IBM Research - Zurich
[email protected]

License

The source code in this repository is licensed under the terms of the Apache License (Version 2.0), unless otherwise specified. See LICENSE for details.

floatx's Issues

Conversion Ambiguous

Hello! I am trying to integrate FloatX into the Eigen library. One particular portion (Eigen::HouseholderQR matrix) is giving me some trouble. In particular, I'm getting the following error, which I think is the key to figuring out this compilation error:

error: conversion from 'long int' to 'const flx::floatx<8,23>' is ambiguous

Do you have an idea of how to address this? Thanks!

Here is a simple example:

#include <iostream>
#include <Eigen/Eigen>

#include "floatx.hpp"

using fx = flx::floatx<8,23>;

// support for eigen library
namespace Eigen {
    template<int E, int M>
    struct NumTraits<flx::floatx<E,M>> : NumTraits<double>
    {
        typedef flx::floatx<E,M> Real;
        typedef flx::floatx<E,M> NonInteger;
        typedef flx::floatx<E,M> Nested;
      
        enum {
            IsComplex = 0,
            IsInteger = 0,
            IsSigned = 1,
            RequireInitialization = 0,
            ReadCost = 1,
            AddCost = 3,
            MulCost = 3
        };
    };
}

int main() {
    Eigen::Matrix<fx,3,3> m;
    m << fx(1), fx(2), fx(3),
         fx(4), fx(5), fx(6),
         fx(7), fx(8), fx(9);

    Eigen::Matrix<fx,3,1> v;
    v << fx(1), fx(2), fx(3);

    Eigen::Matrix<fx,3,1> m2 = m * v;
    Eigen::HouseholderQR<Eigen::Matrix<fx,Eigen::Dynamic,Eigen::Dynamic>> qr(m);
    Eigen::Matrix<fx,Eigen::Dynamic,Eigen::Dynamic> Q = qr.householderQ();

    std::cout << m << std::endl;
    std::cout << m2 << std::endl;
    std::cout << Q << std::endl;
}

I also had to make the following adjustments to floatx.hpp in the floatx class:

 177 //    template <typename T>
 178 //    FLOATX_ATTRIBUTES floatx(const T& other) noexcept
 179 //        : detail::floatx_base<floatx>(backend_float(other))
 180 //    {
 181 //        this->initialize();
 182 //    }
 183 
 184     template <int E, int M>
 185     FLOATX_ATTRIBUTES floatx(const floatx<E,M>& other) noexcept
 186         : detail::floatx_base<floatx>(backend_float(other))
 187     {
 188         this->initialize();
 189     }
 190 
 191     FLOATX_ATTRIBUTES floatx(const float other) noexcept
 192         : detail::floatx_base<floatx>(backend_float(other))
 193     {
 194         this->initialize();
 195     }
 196 
 197     FLOATX_ATTRIBUTES floatx(const int other) noexcept
 198         : detail::floatx_base<floatx>(backend_float(other))
 199     {
 200         this->initialize();
 201     }
 202 
 203     FLOATX_ATTRIBUTES floatx(const double other) noexcept
 204         : detail::floatx_base<floatx>(backend_float(other))
 205     {
 206         this->initialize();
 207     }

Truncating NaNs and Infs

@antodo was doing some changes to the paper - trying to explain why we truncate NaNs and Inf, and figured out we do not actually need to do it.
Since we are already storing the data to the backed type, an not in lower precision, we can just store whatever was there before (it's still a NaN or Info).

Basically, we should be able to just delete the following line: https://github.com/oprecomp/FloatX/blob/master/src/floatx.hpp#L1015

gtest dependency no longer has a 'master' branch

Hi, good people!
Writing you to inform you that the gtest library no longer has a 'master' branch/tag, so the build of the library with CMake fails.
After changing to 'main' in the CMakeLists.txt of the gtest library I got it working.