Computing correctly rounded logarithms with fixed-point operations. Julien Le Maire, Florent de Dinechin, Jean-Michel Muller and Nicolas Brunie

Transcription

1 Computing correctly rounded logarithms with fixed-point operations Julien Le Maire, Florent de Dinechin, Jean-Michel Muller and Nicolas Brunie

2 Outline Introduction and context Algorithm Results and comparisons Conclusions J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 2

3 Logarithm, the mathematical version y y = ln(x) x J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 3

4 Logarithm, the mathematical version ln (a b) = ln (a) + ln (b) 2 y y = ln(x) x J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 3

5 Logarithm, the mathematical version ln (a b) = ln (a) + ln (b) ln (b a ) = a ln(b) 2 y y = ln(x) x J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 3

6 Logarithm, the mathematical version ln (a b) = ln (a) + ln (b) ln (b a ) = a ln(b) Taylor: for x small, ln(1 + x) x x 2 /2 + x 3 /3... y y = ln(x) x J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 3

7 Logarithm, the floating-point version The floating point version of the natural logarithm is called log (you will also find log2 and log10 and a few others) 2 y x F 64 log(x) = (ln(x)) y = ln(x) x J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 4

8 Logarithm, the floating-point version The floating point version of the natural logarithm is called log (you will also find log2 and log10 and a few others) 2 y x F 64 log(x) = (ln(x)) y = ln(x) x An experiment Implementing the floating-point logarithm function using only integer arithmetic for performance (previous work motivated by lack of FP hardware) J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 4

9 Why using fixed-point arithmetic? bits IEEE-754 (64 bits) mainstream floating-point mainstream integer J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 5

10 Why using fixed-point arithmetic? bits IEEE-754 (64 bits) 64-bits mainstream floating-point mainstream integer 64-bit floating-point, but only 52-bit precision if you can predict the value of the exponent, exponent bits are wasted bits. J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 5

11 Integer better than floating-point? modern 64-bit machines offer all sort of useful integer instructions addition multiplication 64x (mulq) count leading zeroes, shifts (lzcnt, bsr) J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 6

12 Integer better than floating-point? modern 64-bit machines offer all sort of useful integer instructions addition multiplication 64x (mulq) count leading zeroes, shifts (lzcnt, bsr) most operations are faster on integers, especially addition (which more or less defines the processor cycle time) J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 6

13 Integer better than floating-point? modern 64-bit machines offer all sort of useful integer instructions addition multiplication 64x (mulq) count leading zeroes, shifts (lzcnt, bsr) most operations are faster on integers, especially addition (which more or less defines the processor cycle time) multiprecision faster and simpler using integers J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 6

14 Integer better than floating-point? modern 64-bit machines offer all sort of useful integer instructions addition multiplication 64x (mulq) count leading zeroes, shifts (lzcnt, bsr) most operations are faster on integers, especially addition (which more or less defines the processor cycle time) multiprecision faster and simpler using integers small multiprecision out of the box: mainstream compilers (gcc, clang, icc) support int_128 addition 128x shift on two registers (add, adc) (shld, shrd) J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 6

15 Integer better than floating-point? modern 64-bit machines offer all sort of useful integer instructions addition multiplication 64x (mulq) count leading zeroes, shifts (lzcnt, bsr) most operations are faster on integers, especially addition (which more or less defines the processor cycle time) multiprecision faster and simpler using integers small multiprecision out of the box: mainstream compilers (gcc, clang, icc) support int_128 addition 128x shift on two registers (add, adc) (shld, shrd) Caveat: integer SIMD/vector support still lagging behind FP (no vector multiplication) J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 6

16 Outline Introduction and context Algorithm Results and comparisons Conclusions J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 7

17 On-demand accuracy Muller and Lefèvre solved the table maker dilema for ln Computing the log with an error enables correct rounding two consecutive floating-point numbers real numbers computed logarithm, with error margin J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 8

18 On-demand accuracy Muller and Lefèvre solved the table maker dilema for ln Computing the log with an error enables correct rounding two consecutive floating-point numbers real numbers computed logarithm, with error margin J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 8

19 On-demand accuracy Muller and Lefèvre solved the table maker dilema for ln Computing the log with an error enables correct rounding two consecutive floating-point numbers real numbers computed logarithm, with error margin CRLibm refinement of Ziv s technique: First step: quick-and-dirty evaluation of ln(x) (just accurate enough to ensure correct rounding in most cases) test if rounding can be decided if not (rarely), recompute ln(x) with the worst-case accuracy J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 8

20 On-demand accuracy Muller and Lefèvre solved the table maker dilema for ln Computing the log with an error enables correct rounding two consecutive floating-point numbers real numbers computed logarithm, with error margin CRLibm refinement of Ziv s technique: First step: quick-and-dirty evaluation of ln(x) (just accurate enough to ensure correct rounding in most cases) test if rounding can be decided if not (rarely), recompute ln(x) with the worst-case accuracy Trade-off between first and second steps: MeanTime = Time(1st step) + Pr[need 2nd step] Time(2nd step) J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 8

21 On-demand accuracy Muller and Lefèvre solved the table maker dilema for ln Computing the log with an error enables correct rounding two consecutive floating-point numbers real numbers computed logarithm, with error margin CRLibm refinement of Ziv s technique: First step: quick-and-dirty evaluation of ln(x) (just accurate enough to ensure correct rounding in most cases) test if rounding can be decided if not (rarely), recompute ln(x) with the worst-case accuracy Trade-off between first and second steps: MeanTime = Time(1st step) + Pr[need 2nd step] Time(2nd step) Best so far: Time(2nd step) 10 Time(1st step) This work: Time(2nd step) 2 Time(1st step) J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 8

22 The big picture 1. Filter special cases (negative numbers,,...) 2. Argument range reduction 3. Polynomial approximation 4. Solution reconstruction 5. Error evaluation and rounding test 6. If more accuracy needed: Rerun the steps 3 and 4 with the worst-case accuracy. J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 9

23 First argument range reduction input = 2 E (1 + x) ln(input) = E ln (2) + ln (1 + x) J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 10

24 First argument range reduction input = 2 E (1 + x) ln(input) = E ln (2) + ln (1 + x) Evaluation algorithm: approximate ln (1 + x) with a polynomial p(x) degree needed: at least 26 evaluate E ln (2) add both terms J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 10

25 Tang s range reduction 1 + x: 1. fractional part on 52 bits 1 + x 1 : 1. fractional part on 7 bits J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 11

26 Tang s range reduction 1 + x: 1. fractional part on 52 bits 1 + x 1 : 1. fractional part on 7 bits r x : 0. fractional part on 18 bits A table, addressed by x 1, the 7 most significand bits of x, stores r x 1 1 ( ) 1 and ln 1 + x x r x J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 11

27 Tang s range reduction 1 + x: 1. fractional part on 52 bits 1 + x 1 : 1. fractional part on 7 bits r x : 0. fractional part on 18 bits 1 + y: fractional part on 64 bits plus 6 implicit zeros A table, addressed by x 1, the 7 most significand bits of x, stores r x 1 1 ( ) 1 and ln 1 + x x Define 1 + y = r x (1 + x) 1 Then ln(1 + x) = ln(1 + y) + ln( 1 r x ) r x J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 11

28 Tang s range reduction algorithm 1 + x: 1. fractional part on 52 bits 1 + x 1 : 1. fractional part on 7 bits r x : 0. fractional part on 18 bits 1 + y: fractional part on 64 bits plus 6 implicit zeros Extract the index x 1 Read, from a table addressed by x 1, both r x and ln( 1 r x ) compute y = r x (1 + x) 1 (exactly) approximate ln (1 + y) with a polynomial p(y) Degree needed: 8 add it all: ln(input) E ln (2) + p (y) + ln( 1 ) r x J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 12

29 Tang s range reduction 1 + x: 1. fractional part on 52 bits 1 + x 1 : 1. fractional part on 7 bits r x : 0. fractional part on 18 bits 1 + y: fractional part on 64 bits plus 6 implicit zeros y = r x (1 + x) 1 With 1 + x on 53 bits we can tabulate r x on 18 bits: the exact product would need 71 bits but we can predict the 7 leading bits... so we can let them overflow quietly and use a multiplication. J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 13

30 Two levels of Tang reduction 1 + x: 1. fractional part on 52 bits 1 + x 1 : 0. fractional part on 7 bits r x : 0. fractional part on 9 bits 1 + y: y 1 : fractional part on 60 bits including 5 zeros. fractional part on 13 bits r y : 0. fractional part on 15 bits 1 + z: fractional part on 64 bits plus 12 implicit zeros x [0, 1) y [ 0, ) x 1 takes 64 different values z [ 0, ) y 1 takes 96 different values the whole reduction of x to z is computed exactly in 64-bit int. J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 14

31 A few Pareto points in the design space Table size (bytes) degree 1st degree 2nd 39, , , , , J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 15

32 Why stop at two levels of reduction? Answer is: diminushing return. For a target accuracy of 2 60 : interval of x degree needed No reduction [ 1/2, 1/2] 29 1 level [ 2 7, 2 7 ] 8 2 levels [ 2 12, 2 12 ] 4 3 levels [ 2 18, 2 18 ] 3 Adding more levels will cost more operations than it saves... J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 16

33 Polynomial approximation (advertisement) We want to approximate log(1 + z) on an interval around 0. Use the (now standard) tool set to obtain it. Sollya: finds a machine-efficient polynomial P(z) computes a safe bound on the approximation error P(z) ln(1 + z) Gappa: bounds the accumulation of rounding errors when evaluating P(z) in C We obtain a Coq proof of the error: computed approximation of ln(1 + z), with relative error margin real numbers J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 17

34 Reconstructing the solution input = 2 e (1 + x) J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 18

35 Reconstructing the solution input = 2 e 1 r x (1 + y) J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 18

36 Reconstructing the solution input = 2 e 1 r x 1 r y (1 + z) J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 18

37 Reconstructing the solution input = 2 e 1 r x 1 r y (1 + z) ln(input) = e ln(2) + ln(r x 1 ) + ln(r y 1 ) + ln(1 + z) J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 18

38 Reconstructing the solution input = 2 e 1 r x 1 r y (1 + z) ln(input) = e ln(2) + ln(r x 1 ) + ln(r y 1 ) + ln(1 + z) e ln(2): ln(r x 1 ): ln(r y 1 ): P(z) ln(1 + z): sum: If we can predict the exponents, exponent bits are wasted bits J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 18

39 Reconstructing the solution input = 2 e 1 r x 1 r y (1 + z) ln(input) = e ln(2) + ln(r x 1 ) + ln(r y 1 ) + ln(1 + z) e ln(2): ln(r x 1 ): ln(r y 1 ): P(z) ln(1 + z): sum: If we can predict the exponents, exponent bits are wasted bits J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 18

40 Reconstructing the solution input = 2 e 1 r x 1 r y (1 + z) ln(input) = e ln(2) + ln(r x 1 ) + ln(r y 1 ) + ln(1 + z) e ln(2): ln(r x 1 ): ln(r y 1 ): P(z) ln(1 + z): sum: If we can predict the exponents, exponent bits are wasted bits J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 18

41 Reconstructing the solution input = 2 e 1 r x 1 r y (1 + z) ln(input) = e ln(2) + ln(r x 1 ) + ln(r y 1 ) + ln(1 + z) e ln(2): ln(r x 1 ): ln(r y 1 ): P(z) ln(1 + z): sum: If we can predict the exponents, exponent bits are wasted bits J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 18

42 Error evaluation e ln(2): ln(r x 1 ): ln(r y 1 ): P(z) ln(1 + z): sum: J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 19

43 Error evaluation e ln(2): ln(r x 1 ): ln(r y 1 ): P(z) ln(1 + z): sum: ɛ < ( e ) J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 19

44 Error evaluation e ln(2): ln(r x 1 ): ln(r y 1 ): P(z) ln(1 + z): sum: ɛ < ( e ) J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 19

45 Error evaluation e ln(2): ln(r x 1 ): ln(r y 1 ): P(z) ln(1 + z): sum: ɛ < ( e P(z) 2 59) J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 19

46 Rounding test Simple technique: compute the two bounds of the interval, and see if they round to the same mantissa (two additions, a xor and a shift) real numbers J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 20

47 Rounding test Simple technique: compute the two bounds of the interval, and see if they round to the same mantissa (two additions, a xor and a shift) real numbers J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 20

48 Rounding test Simple technique: compute the two bounds of the interval, and see if they round to the same mantissa (two additions, a xor and a shift) real numbers For comparison, the proof of the floating-point-based rounding test (invented by Ziv and used in CRLibm) is an 18-page paper that took 20 years to publish... J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 20

49 Second step Use 3 words instead of 2 for the precomputed ln(2) Use a much more accurate polynomial: with coefficients on 128 bits instead of 64 (but z is still only a 64-bit number) and using a higher degree polynomial J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 21

50 Outline Introduction and context Algorithm Results and comparisons Conclusions J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 22

51 Implementation parameters of correctly rounded implementations glibc crlibm-td crlibm-de cr-fixp degree pol. 1 3/ degree pol tables size 13 Kb 8192 bytes 6144 bytes 4032 bytes % accurate phase N/A J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 23

52 Average and max runing time (in processor cycles) Pentium timing (lower is better) cycles MKL glibc crlibm cr-de cr-fixp avg time max time 25 11, Timing breakdown on two processors cycles Core i5 Bostan System glibc newlib quick phase alone accurate phase alone both phases (avg time) both phases (max time) Slanted means: no correct rounding J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 24

53 Average and max runing time (in processor cycles) Pentium timing (lower is better) cycles MKL glibc crlibm cr-de cr-fixp avg time max time 25 11, Timing breakdown on two processors cycles Core i5 Bostan System glibc newlib quick phase alone accurate phase alone both phases (avg time) both phases (max time) Slanted means: no correct rounding J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 24

54 Average and max runing time (in processor cycles) Pentium timing (lower is better) cycles MKL glibc crlibm cr-de cr-fixp avg time max time 25 11, Timing breakdown on two processors cycles Core i5 Bostan System glibc newlib quick phase alone accurate phase alone both phases (avg time) both phases (max time) Slanted means: no correct rounding J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 24

55 Average and max runing time (in processor cycles) Pentium timing (lower is better) cycles MKL glibc crlibm cr-de cr-fixp avg time max time 25 11, Timing breakdown on two processors cycles Core i5 Bostan System glibc newlib quick phase alone accurate phase alone both phases (avg time) both phases (max time) Slanted means: no correct rounding J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 24

56 Outline Introduction and context Algorithm Results and comparisons Conclusions J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 25

57 Conclusions Better range reduction thanks to a wider format... leading to improvements in polynomial degree and table size Faster multiprecision due to higher precision Able to reuse some computations of the fast step in the accurate step Alternative rounding test for acurate step Probability to launch 2nd step is high, but this is acceptable since 2nd step is so cheap J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 26

58 Conclusions Better range reduction thanks to a wider format... leading to improvements in polynomial degree and table size Faster multiprecision due to higher precision Able to reuse some computations of the fast step in the accurate step Alternative rounding test for acurate step Probability to launch 2nd step is high, but this is acceptable since 2nd step is so cheap Competitive against state-of-the-art Worst case improved compared to others implementations Second step-only version is a viable alternative J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 26

59 Conclusions Better range reduction thanks to a wider format... leading to improvements in polynomial degree and table size Faster multiprecision due to higher precision Able to reuse some computations of the fast step in the accurate step Alternative rounding test for acurate step Probability to launch 2nd step is high, but this is acceptable since 2nd step is so cheap Competitive against state-of-the-art Worst case improved compared to others implementations Second step-only version is a viable alternative Limitations: Require 64 bits integer support No support for vectorization J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 26

60 Thanks for your attention Any question? J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 27

61 Outline Bonus: a floating-point in, fixed-point out variant Some code details on the solution reconstruction J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 28

62 Floating-point in, fixed-point out output: fixed-point, 11 bits integer part, 53 bit fractional part integer part target absolute accuracy 2 52 fraction output absolute table Core i5 Bostan format accuracy size cycles cycles Fix Fix double (libm) Fix64 is the code of the first step only, without the conversion to float. tweak: poly degree 3 only for abs. accuracy 2 59 Fix128 is the code of the second step only, without the conversion to float. J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 29

63 Motivation TKF91 : DNA sequence alignment algorithm dynamic programming algorithm: alignment as a path within a 2D array. borders of an array initialized with log-likelihoods then array filled using recurrence formulae that involve only max and + operations. All current implementations of this algorithm use a floating-point array, but int64 + and max are 1-cycle, vectorizable, and exact operations; absolute accuracy of initialization logs: up to 2 42 with FP log, 2 52 with FixP log. J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 30

64 Only partial experiments Improvement in accuracy measured No noticeable improvement in performance J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 31

65 Outline Bonus: a floating-point in, fixed-point out variant Some code details on the solution reconstruction J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 32

66 Special cases: businesss as usual / r e i n t e r p r e t x to m a n i p u l a t e i t s b i t s more e a s i l y / u i n t 6 4 _ t i n p u t b i t s = ( ( union { double d ; u i n t 6 4 _ t u ; }){ i n p u t } ). u ; i n t xe = i n p u t b i t s >> 5 2 ; / f i l t e r t h e s p e c i a l c a s e s :! ( x i s n o r m a l i z e d and 0 < x < +I n f ) i f (0 x7feu <= ( unsigned ) xe 1u ) { / x = + 0 : r a i s e a D i v i d e B y z e r o, r e t u r n I n f / i f ( ( x b i t s & ~(1 u l l << 6 3 ) ) == 0) r e t u r n 1.0/0.0; / x < 0. 0 : r a i s e a I n v a l i d O p e r a t i o n, r e t u r n a qnan / i f ( ( x b i t s & (1 u l l << 6 3 ) )!= 0) r e t u r n ( x x ) / 0 ; / x = qnan : r e t u r n a qnan x = snan : r a i s e a I n v a l i d O p e r a t i o n, r e t u r n a qnan x = +I n f : r e t u r n +I n f / i f ( xe!= 0) r e t u r n x+x ; / x subnormal : change x to a n o r m a l i z e d number / e l s e { i n t u = c l z 6 4 ( x b i t s ) 1 2 ; x b i t s <<= u + 1 ; xe = u ; } } xe = ; Only interesting line: the subnormal management J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 33

67 Argument reduction / i n p u t = 2^ xe (1 + X) / u i n t 6 4 _ t x = i n p u t b i t s & 0 xfffffffffffffull ; / 1 + X = ( 1/ Ri ) Y / u i n t 8 _ t x1 = x >> (52 ARG_REDUC_1_PREC ) ; u i n t 6 4 _ t y = argreduc1_inv [ x1 ] ( x + (1 u l l << 5 2 ) ) ; b u i l t i n _ p r e f e t c h (& argreduc1_log [ x1 ], 0, 0 ) ; / Y = (1/ S ) (1 + Z) / / w i t h dz = dz /2^(52 + ARG_REDUC_1_SIZE + ARG_REDUC_2_SIZE) and 1/S = argreduc2 [ s i ]. v a l /2^ARG_REDUC_2_SIZE / u i n t 8 _ t y1 = ( y >> ( 52 + ARG_REDUC_1_SIZE ARG_REDUC_2_PREC) ) ( 1 u << ARG_REDUC_2_PREC ) ; u i n t 6 4 _ t z = argreduc2_inv [ y1 ] y ; // +1 p a r t removed by o v e r f l o w b u i l t i n _ p r e f e t c h (& argreduc2_log [ y1 ], 0, 0 ) ; J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 34

68 Polynomial evaluation / P o l y n o m i a l a p p r o x i m a t i o n o f l o g (1+Z)/Z ~= P(Z) and Z P(Z) / s t a t i c c o n s t u i n t 6 4 _ t a4 = UINT64_C (0 x 3 f f c c b ) ; s t a t i c c o n s t u i n t 6 4 _ t a3 = UINT64_C (0 x d c 7 0 f 0 d f d ) ; s t a t i c c o n s t u i n t 6 4 _ t a2 = UINT64_C (0 x 7 f f f f f f f f f d f d ) ; s t a t i c c o n s t u i n t 6 4 _ t a1 = UINT64_C (0 x f f f f f f f f f f f f f f f a ) ; u i n t 6 4 _ t pz = a1 ( highmul ( z, a2 ( highmul ( z, a3 ( highmul ( z, a4 ) >> 12) ) >> 12) ) >> 1 2 ) ; u i n t _ t zpz = f u l l m u l ( z, pz ) ; / P o l y n o m i a l a p p r o x i m a t i o n w i t h o u t s h i f t s : r e p l a c e highmul ( z, a ) >> 12 w i t h highmul ( z, a >> 12) / s t a t i c c o n s t u i n t 6 4 _ t a4 = UINT64_C (0 x f f c ) ; s t a t i c c o n s t u i n t 6 4 _ t a3 = UINT64_C (0 x dc6 ) ; s t a t i c c o n s t u i n t 6 4 _ t a2 = UINT64_C (0 x f f f f f f f f f d 5 7 ) ; s t a t i c c o n s t u i n t 6 4 _ t a1 = UINT64_C (0 x f f f f f f f f f f f f f f f a ) ; u i n t 6 4 _ t pz = a1 highmul ( z, a2 highmul ( z, a3 highmul ( z, a4 ) ) ) ; u i n t _ t zpz = f u l l m u l ( z, pz ) ; J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 35

69 Reconstructing the solution / Compute p a r t o f t h e r e s u l t t h a t don t depend on Z ( xe l o g ( 2 ) + l o g (1/ Ri ) + l o g (1/ S i ) ) / u i n t _ t c s t p a r t = f u l l i m u l ( xe, log2fw_mid ) + UINT128 ( ( i n t 6 4 _ t ) xe log2fw_high, 0) // f u l l m u l not needed + UINT128 ( argreduc1 [ r i ]. l o g _ hi, argreduc1 [ r i ]. l o g _ l o ) + UINT128 ( argreduc2 [ s i ]. l o g_hi, argreduc2 [ s i ]. l o g _ l o ) ; / P o l y n o m i a l a p p r o x i m a t i o n o f l o g (1+Z)/Z ~= P(Z) and Z P(Z) /... / Assemble t h e two p a r t s, compute s i g n, m a n t i s s a and exponent / u i n t _ t l o n g r e s = c s t p a r t + ( zpz >> (11 + IMPLICIT_ZEROS ) ) ; u i n t 6 4 _ t s i g n = ( HI ( l o n g r e s ) >> 6 3 ) ; // 0 o r ~0 // i f s i g n!= 0, t h i s i s l o n g r e s = ~ l o n g r e s ( a = ~a + 1) // to a v o i d t h e +1 approx, do : // l o n g r e s = ( ( i n t 6 4 _ t ) s i g n + l o n g r e s ) ^ UINT128 ( s i g n, s i g n ) ; l o n g r e s ^= UINT128 ( s i g n, s i g n ) ; i n t u = c l z 6 4 ( HI ( l o n g r e s ) ) + 1 ; i n t exponent = 11 u ; u i n t 6 4 _ t m a n t i s s a = ( HI ( l o n g r e s ) << u ) (LO( l o n g r e s ) >> (64 u ) ) J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 36

70 Rounding test and conversion / Compute t h e maximal a b s o l u t e e r r o r ( a l i g n e d w i t h l o n g r e s ) : abs ( xe ) f o r xe l o g ( 2 ), l o g (1/ Ri ) and l o g (1/ S i ) zpz >>(POLYNOMIAL_PREC+IMPLICIT_ZEROS+11) f o r t h e p o l y n o I f r e s u l t (1 + maxrelerr ) a r e not rounded to t h e same number, we u i n t 6 4 _ t maxabserr = 3 + abs ( xe ) + ( HI ( zpz ) >> (POLYNOMIAL_PREC + u i n t 6 4 _ t maxrelerr = ( maxabserr >> (64 u ) ) + 1 ; i f ( ( ( m a n t i s s a + maxrelerr ) ^ ( m a n t i s s a maxrelerr ) ) >> 11) { r e t u r n l o g _ r n _ a c c u r a t e ( c s t p a r t, z, xe ) ; } / Assemble t h e computed r e s u l t / u i n t 6 4 _ t r e s u l t b i t s = ( ( u i n t 6 4 _ t ) s i g n << 63) + ( ( u i n t 6 4 _ t ) ( exponent +1023) << 52) + ( m a n t i s s a >> 12) + ( ( m a n t i s s a >> 11) & 1 ) ; / round to n e a r e s t / r e t u r n ( union { u i n t 6 4 _ t u ; double d ; }){ r e s u l t b i t s }. d ; J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 37

71 Outline Bonus: a floating-point in, fixed-point out variant Some code details on the solution reconstruction J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 38

72 Reconstructing the solution e ln(2): ln(r x 1 ): ln(r y 1 ): P(z) ln(1 + z): sum: J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 39

73 Reconstructing the solution e ln(2): ln(r x 1 ): ln(r y 1 ): P(z) ln(1 + z): sum: 1 floating-point fraction J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 39

74 Reconstructing the solution e ln(2): ln(r x 1 ): ln(r y 1 ): P(z) ln(1 + z): sum: 1 floating-point fraction J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 39

75 Reconstructing the solution e ln(2): ln(r x 1 ): ln(r y 1 ): P(z) ln(1 + z): sum: 1 floating-point fraction J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 39

76 Reconstructing the solution e ln(2): ln(r x 1 ): ln(r y 1 ): P(z) ln(1 + z): sum: 1 floating-point fraction J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 39

77 Reconstructing the solution e ln(2): ln(r x 1 ): ln(r y 1 ): P(z) ln(1 + z): sum: 1 floating-point fraction J. Le Maire, F. de Dinechin, J.-M. Muller and N. Brunie Computing correctly rounded logarithm with fixed-point operations 39