"La computación es la ciencia de la abstracción".

¿Mapeo no inyectivo R -> cantidad finita de bits?

• BCD: 123.45 -> 0001 0010 0011 0100 0101
• Racionales: 123.45 -> 12345/100
• Punto fijo: 123.45 -> 11000000111001
• Mantisa/Exponente: 123.45 -> 0.12345 * 10^3

Si hacemos arqueología computacional, vamos a encontrar de todo.

• Ferranti Mercury.
• IBM 1620 Computer with ADvanced Economic Technology (crítica)
• IBM 360.
• MS Basic (MBF).

Hay cosas curiosas, la ZX81 sólo manejaba flotantes cuando su µP sumaba enteros de hasta 16 bits.

(-1)^s * (1+mantisa) * 2^{exponente-offset}

Verdades de Pedro Grullo:

• No podemos capturar todos los racionales.
• Hay más precisión cerca del 0.
• Hay un máximo y mínimo positivo (negativo).
• Estaría bueno tener representaciones denormalizadas.

El no-determinismo en el orden de la suma se pierde.
No es un conjunto es una secuencia.

Secuencialidad => Corrección

¿Adiós paralelismo!

• Recetas para sumar bien.
• Recetas para sumar mal, pero rápido ... muy rápido.

Shhh, no le digan a nadie ...

El estándar de "C" dice que (x+y)+z se puede evaluar como x+(y+z), pero en el C Standard 5.1.2.3 Program execution previene diferentes evaluaciones si dan diferentes resultados.

¿Y del inverso multiplicativo?

Transformar divisiones en multiplicaciones siempre que se pueda.

También define el "como" de las computaciones:

• Suma, resta.
• Multiplicación, división.
• Raíz cuadrada.
• Conversion de y hacia enteros.

Hay no-determinismo en esta especificación
Esto permite diferentes implementaciones.

Implementaciones: ARM, Intel, Cray, NVIDIA, AMD, Xilnix, IBM, ...

Mejora la precisión

Todas las implementaciones permiten modificar el rounding mode.

Karen Miller, Floating Point Representation, 2006.

Notar

• El cero es un ristra de bits en 000...0.
• Números denormalizados para un gradual underflow.
• Como operan los valores especiales.
  • NaN es una constante que se propaga infinitamente.

• Los costos (velocidad) dependen de la plataforma (Intel, AMD, NVIDIA).
• fp64 ocupa el doble de memoria.
  • Doble de transferencia y la memoria es LENTA.

Notas

• Usualmente hay mayores costos asociados a fp64.
  • La diferencia entre una GTX 780 y una Tesla K20c.
• Lo ideal es armar algoritmos mixed precision.
• Antes era fp16, fp24 y no IEEE754 compatible.
  • Gaming!
  • La GTX 280 no era IEEE754, recién CC2.0 (Fermi) fue IEEE754.
• Ahora está de moda fp16 para DNN y están encastrados en los Tensor Cores de Volta.
• Intel siempre fue internamente fp80 y por fuera fp32 o fp64.

Ryan Smith, The NVIDIA GeForce GTX 1080 & GTX 1070 Founders Editions Review: Kicking Off the FinFET Generation, Anandtech, July 2016.

• R. Munroe, Coordinate Precision, XKCD 2170.

Matsuoka et.al, Double-precision FPUs in High-PerformanceComputing: an Embarrassment of Riches?, 2019.

A snail in the coffin for Linpack and its stunt machines.

By studying a large number of HPC proxy application, we found no significant performance difference between these two processors, despite one having more double-precision compute than the other.

Mixed precision algorithms FTW!
¡Todos los paquetes de MD!

bfloat16

Facebook floating point math

We have developed an alternate approach to making AI models run efficiently. Building on a lineage of ideas reaching back to the early days of computer science more than 70 years ago, our method optimizes floating point itself.

Daniel Lemire

How many floating-point numbers are in the interval [0,1]?, 2017.

-- no me convence, no pude hacer el experimento que yo quería, lo dejo para que alguien lo mire --

nvcc

--use_fast_math                                    (-use_fast_math)             
        Make use of fast math library. -use_fast_math implies -ftz=true 
        -prec-div=false -prec-sqrt=false.

--ftz [true,false]                                 (-ftz)                       
        When performing single-precision floating-point operations, flush 
        denormal values to zero or preserve denormal values. -use_fast_math 
        implies --ftz=true.
        Default value:  0.

--prec-div [true,false]                            (-prec-div)                  
        For single-precision floating-point division and reciprocals, use IEEE 
        round-to-nearest mode or use a faster approximation. -use_fast_math 
        implies --prec-div=false.
        Default value:  1.

--prec-sqrt [true,false]                           (-prec-sqrt)                 
        For single-precision floating-point square root, use IEEE 
        round-to-nearest mode or use a faster approximation. -use_fast_math 
        implies --prec-sqrt=false.
        Default value:  1.

--fmad [true,false]                                (-fmad)                      
        Enables (disables) the contraction of floating-point multiplies and 
        adds/subtracts into floating-point multiply-add operations (FMAD, FFMA, 
        or DFMA). This option is supported only when '--gpu-architecture' is 
        set with compute_20, sm_20, or higher. For other architecture classes, 
        the contraction is always enabled. -use_fast_math implies --fmad=true.
        Default value:  1.

gcc

-ffast-math
   Sets -fno-math-errno, -funsafe-math-optimizations, -ffinite-math-only, -fno-rounding-math, -fno-signaling-nans and
   -fcx-limited-range.

-funsafe-math-optimizations
   Allow optimizations for floating-point arithmetic that (a) assume that arguments and results are valid and (b) may violate IEEE
   or ANSI standards.  When used at link-time, it may include libraries or startup files that change the default FPU control word
   or other similar optimizations.

   This option is not turned on by any -O option since it can result in incorrect output for programs that depend on an exact
   implementation of IEEE or ISO rules/specifications for math functions. It may, however, yield faster code for programs that do
   not require the guarantees of these specifications.  Enables -fno-signed-zeros, -fno-trapping-math, -fassociative-math and
   -freciprocal-math.

   The default is -fno-unsafe-math-optimizations.

Intel SSE3

Modificar el registro de estado MXCSR.

FZ  bit 15  Flush To Zero
R+  bit 14  Round Positive
R-  bit 13  Round Negative
RZ  bits 13 and 14  Round To Zero
RN  bits 13 and 14 are 0    Round To Nearest

NVIDIA Kepler

Modificadores de las instrucciones de assembler:

.rn  Round to nearest even.
.rz  Round towards zero.
.rm  Round towards -infty.
.rp  Round towards +infty.

• Buscar switches para relajar o reforzar compatibilidad IEEE.
• Usar fp64 de manera juiciosa (ancho de banda, memoria).
  • Ej: LAMMPS computa dinámica en fp64 y almacena los vectores en fp32.
• Sumar ordenadamente.
• Multiplicar antes que las divisiones cuando se pueda.
• Multiplicar en vez de dividir.
• Comparar por valores cercanos, no iguales.
• MUCHÍSIMO CUIDADO con las conversiones de tipo.

John Gustafson, A Radical Approach to Computation with Real Numbers, JSFI, 2016.

• Overflow
  • Más performance, mayor tamaño (Gustafson's Law) y con N grande es fácil hacer overflow.
• ¿Con o sin signo?
  • Compilación más estricta.
  • Mas bits de alcance.
• Tipos ajustados en general.
  • Más posibilidades de optimización.
  • Más información para que el compilador detecte errores en compile time.
• Órden en las operaciones.

Conversiones de tipo!

R. Munroe, INT(PI), XKCD 1275.

• Charles Severance, Kevin Dowd, "High Performance Computing", Connexions, 2010, CC3.0.
• David Goldberg, "What Every Programmer should know about floating point numbers", ACM Computer Surveys, 1991.
• Daniel Lemire, How many floating-point numbers are in the interval [0,1]?, 2017.
• Matsuoka et.al, Double-precision FPUs in High-PerformanceComputing: an Embarrassment of Riches?, 2019.

• Como funciona un µP moderno.

La otra

• ¿Qué pasó desde el 8080 hasta Haswell?

La otra²

• Todo lo que no hay que hacer porque el compilador ya lo hace.