Fix a few issues raised in PR#3 review.

- remove extra code / spurious comments
- radically simplify FloatImmediate checkValue
- remove offset and n_levels from FloatAddTemplate

Author: FrancescoConti

Deeploy/AbstractDataTypes.py

@@ -236,9 +236,9 @@ def checkValue(cls, value: Union[int, Iterable[int]], ctxt: Optional[_NetworkCon
 
 
 class FloatImmediate(Immediate[Union[float, Iterable[float]], _ImmediateType]):
-    typeFraction: int  #: int: Represents the number of bits reserved for the fraction part
-    typeExponent: int  #: int: Represents the number of bits reserved for the exponent part
-    signed: bool  #: bool: Represents whether the underlying float is signed or unsigned (should be removed)
+    # FIXME: check typeFraction vs typeMantissa
+    typeFraction: int       #: int: Represents the number of bits reserved for the fraction part
+    typeExponent: int       #: int: Represents the number of bits reserved for the exponent part    
 
     @_classproperty
     def typeExponentMax(cls) -> int:
@@ -250,7 +250,6 @@ def typeExponentOffset(cls) -> int:
         # The offset added to the exponent
         return 2**(cls.typeExponent - 1) - 1
 
-    # ADEQUINO: This is a ugly workaround for FP, works for bfloat16 and fp32 because bfloat16 is a truncated fp32
     @classmethod
     def partialOrderUpcast(cls, otherCls: Type[Immediate]) -> bool:
         if issubclass(otherCls, FloatImmediate):
@@ -277,92 +276,29 @@ def checkValue(cls, value: Union[float, Iterable[float]], ctxt: Optional[_Networ
         else:
             raise Exception("Immediate type not recognized.")
 
+        # The exponent bias for FP64 is 2**(11-1)-1 as the exponent has 11 bits.
+        DOUBLE_MIN_EXP = -1023
+
         for val in _val_list:
-            # Zero (and subnormals, not implemented) are special cases
-            if (val == 0):
+
+            # Extract mantissa, exponent, and sign.
+            # Also bring mantissa and exponent to IEEE754 compliant form for non-denormals.
+            mantissa, exponent = math.frexp(val)
+            sign = True if mantissa < 0 else False
+            mantissa = -mantissa*2 if sign else mantissa*2
+            exponent -= 1
+
+            # Check if the number is finite, nonzero and not denormal, otherwise skip the check.
+            if not (math.isfinite(val) and val != 0 and exponent > DOUBLE_MIN_EXP):
                 continue
-            # Make the value positive
-            if (val < 0):
-                val = val * -1
-
-            # Separate Integer and Fraction of immediate
-            fraction, integer = math.modf(val)
-
-            # Binarylist for the mantissa
-            binarylist = []
-            f = fraction
-
-            # Fraction binarization, fails if nbits required > n bits mantissa.
-            # If integer part of immediate is 0, we start counting mantissa bits after we find the first 1 bit.
-            if (int(integer) > 0):
-                for i in range(cls.typeFraction):
-                    f = f * 2
-                    f, fint = math.modf(f)
-                    binarylist.append(str(int(fint)))
-                    if f == 0:
-                        break
-                    elif i == (cls.typeFraction - 1):
-                        return False
-            else:
-                flag = 0
-                count = cls.typeFraction + 1
-                while (count):
-                    f = f * 2
-                    f, fint = math.modf(f)
-                    binarylist.append(str(int(fint)))
-                    if int(fint) == 1 and flag == 0:
-                        flag = 1
-                    if f == 0:
-                        break
-                    if flag == 1:
-                        count = count - 1
-                    if (count == 0):
-                        return False
-
-            # Float exponent part
-            # It's equal to the length of the integer part minus 1, if the integer part is not zero.
-            # Otherwise, it's minus the number of 0 bits before the first 1 bit in the fraction representation + 1
-            exponent = 0
-            if (int(bin(int(integer))[2:]) == 0):
-                for b in binarylist:
-                    exponent = exponent - 1
-                    if b == '1':
-                        break
-            else:
-                exponent = len(str(bin(int(integer))[2:])) - 1
-
-            # Check if exponent is representable in n_exponent bits
-            true_exponent = int(bin(cls.typeExponentOffset + exponent)[2:])
+
+            # Check if exponent is representable.
             if (cls.typeExponentOffset + exponent) > cls.typeExponentMax or (cls.typeExponentOffset + exponent) < 0:
                 return False
-
-            # Append bits to head of mantissa, if integer part is not in scientific notion
-            binarylist2 = []
-            if len(str(bin(int(integer))[2:])) > 1:
-                for digit in str(bin(int(integer))[3:]):
-                    binarylist2.append((digit))
-
-            # If integer part is zero, trim the mantissa bits that have been used to calculate the exponent part
-            if (int(integer) > 0):
-                finalbinaryfraction = binarylist2 + binarylist
-            else:
-                finalbinaryfraction = binarylist
-                while (finalbinaryfraction[0] == '0'):
-                    finalbinaryfraction.pop(0)
-                finalbinaryfraction.pop(0)
-
-            # Fix mantissa size
-            if ((cls.typeFraction - len(finalbinaryfraction)) > 0):
-                finalbinaryfraction += ['0'] * (cls.typeFraction - len(finalbinaryfraction))
-            if (len(finalbinaryfraction) > cls.typeFraction):
-                finalbinaryfraction = finalbinaryfraction[:cls.typeFraction]
-
-            # Check if the value in binary float represent the immediate value
-            exponent_part = 2**exponent
-            mantissa_part = 1
-            for (i, m) in enumerate(finalbinaryfraction):
-                mantissa_part = mantissa_part + 2**(-(i + 1)) * int(m)
-            if (exponent_part * mantissa_part != val):
+            
+            # Check if mantissa is representable. Implicit assumption is that cls.typeFraction < 52 (like in FP64)
+            truncated_mantissa = 1 + math.floor((2 ** cls.typeFraction) * (mantissa-1)) / (2 ** cls.typeFraction)
+            if math.fabs(truncated_mantissa - mantissa) > 0.0:
                 return False
 
         return True

Deeploy/CommonExtensions/DataTypes.py

@@ -76,20 +76,19 @@ class uint64_t(IntegerImmediate):
     signed = False
 
 
-class bfloat16(FloatImmediate):
+# BFloat16 in PULP systems
+class float16alt(FloatImmediate):
     typeName = "float16alt"
     typeWidth = 16
     typeFraction = 7
     typeExponent = 8
-    signed = True
 
 
 class float32(FloatImmediate):
     typeName = "float"
     typeWidth = 32
     typeFraction = 23
     typeExponent = 8
-    signed = True
 
 
 SignedIntegerDataTypes: Tuple[Type[IntegerImmediate], ...] = (int8_t, int16_t, int32_t, int64_t)
@@ -99,4 +98,4 @@ class float32(FloatImmediate):
     *UnsignedIntegerDataTypes,
 ),
                                                                key = lambda _type: _type.typeWidth))
-FloatDataTypes: Tuple[Type[FloatImmediate], ...] = (bfloat16, float32)
+FloatDataTypes: Tuple[Type[FloatImmediate], ...] = (float16alt, float32)

Deeploy/Targets/Generic/Templates/FloatAddTemplate.py

@@ -37,26 +37,14 @@ def alignToContext(self, ctxt: NetworkContext,
         data_in_2 = ctxt.lookup(operatorRepresentation['data_in_2'])
         data_out = ctxt.lookup(operatorRepresentation['data_out'])
 
-        input_1_offset = 0
-        if hasattr(data_in_1, "_signed") and hasattr(data_in_1, "nLevels"):
-            input_1_offset = (data_in_1._signed == 0) * int(data_in_1.nLevels / 2)
-        input_2_offset = 0
-        if hasattr(data_in_2, "_signed") and hasattr(data_in_2, "nLevels"):
-            input_2_offset = (data_in_2._signed == 0) * int(data_in_2.nLevels / 2)
-        output_offset = 0
-        if hasattr(data_out, "_signed") and hasattr(data_out, "nLevels"):
-            output_offset = -(data_out._signed == 0) * int(data_out.nLevels // 2)
-
-        operatorRepresentation['offset'] = input_1_offset + input_2_offset + output_offset
-
         return ctxt, operatorRepresentation, []
 
 
 referenceTemplate = _FloatAddTemplate("""
 // Add (Name: ${nodeName}, Op: ${nodeOp})
 BEGIN_SINGLE_CORE
     for (uint32_t i=0;i<${size};i++){
-        ${data_out}[i] = ${data_in_1}[i] + ${data_in_2}[i] + ${offset};
+        ${data_out}[i] = ${data_in_1}[i] + ${data_in_2}[i];
     }
 END_SINGLE_CORE
 """)