Additional benchmarks for Atof including hard denormals.

Change-Id: Id0ca1ac439c74b7643dd5fe556d000aefbd97ef7

Author: remyoudompheng

src/strconv/atof_test.go

@@ -393,27 +393,45 @@ func TestRoundTrip32(t *testing.T) {
 	t.Logf("tested %d float32's", count)
 }
 
-func BenchmarkAtof64Decimal(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		ParseFloat("33909", 64)
-	}
-}
-
-func BenchmarkAtof64Float(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		ParseFloat("339.7784", 64)
-	}
-}
-
-func BenchmarkAtof64FloatExp(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		ParseFloat("-5.09e75", 64)
-	}
+var atofBenches = []struct {
+	name    string
+	arg     string
+	bitSize int
+}{
+	{"64Decimal", "33909", 64},
+	{"64Float", "339.7784", 64},
+	{"64FloatExp", "-5.09e75", 64},
+	{"64Big", "123456789123456789123456789", 64},
+	{"64Denormal", "622666234635.3213e-320", 64},
+	{"32Decimal", "33909", 32},
+	{"32Float", "339.778", 32},
+	{"32FloatExp", "12.3456e32", 32},
+	// Numbers halfway (or close to halfway) between 2 floats
+	{"64HalfwayInt", "100000000000000016777215", 64},
+	{"64HalfwayInt", "100000000000000016777216", 64},
+	// Almost halfway, with less than 1e-16 ulp difference
+	// with only 16 decimal digits.
+	{"64HalfwayHard1", "6808957268280643e116", 64},   // from ftoahard
+	{"64HalfwayHard2", "4.334126125515466e-210", 64}, // from ftoahard
+	// Only 3e-13*ulp larger than halfway between denormals,
+	{"64HalfwayDenormal", "1.68514038588815e-309", 64},
+	// Few digits, but 9.11691642378e-312 = 0x1ada385d67b.7fffffff5d9...p-1074
+	// so naive, rounded 64-bit arithmetic is not enough to round it correctly.
+	{"64HalfwayDenormalShort", "9.11691642378e-312", 64},
+	// 1.62420278e-315 = 0x1398359e.7fffe022p-1074,
+	// should parsable using 64-bit arithmetic.
+	{"64HalfwayDenormalVeryShort", "1.62420278e-315", 64},
+	// https://www.exploringbinary.com/php-hangs-on-numeric-value-2-2250738585072011e-308/
+	{"64Denormal", "2.2250738585072011e-308", 64},
 }
 
-func BenchmarkAtof64Big(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		ParseFloat("123456789123456789123456789", 64)
+func BenchmarkAtof(b *testing.B) {
+	for _, c := range atofBenches {
+		b.Run(c.arg, func(b *testing.B) {
+			for i := 0; i < b.N; i++ {
+				ParseFloat(c.arg, c.bitSize)
+			}
+		})
 	}
 }
 
@@ -429,24 +447,6 @@ func BenchmarkAtof64RandomFloats(b *testing.B) {
 	}
 }
 
-func BenchmarkAtof32Decimal(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		ParseFloat("33909", 32)
-	}
-}
-
-func BenchmarkAtof32Float(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		ParseFloat("339.778", 32)
-	}
-}
-
-func BenchmarkAtof32FloatExp(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		ParseFloat("12.3456e32", 32)
-	}
-}
-
 var float32strings [4096]string
 
 func BenchmarkAtof32Random(b *testing.B) {

src/strconv/ftoahard_test.go

@@ -51,32 +51,48 @@ func GenerateHardFloat64s() []float64 {
 			a = a.Exp(a, big.NewInt(int64(q)), nil)
 			b := big.NewInt(1)
 			b = b.Lsh(b, uint(-(e - 1)))
-			x, y, prec = findFrac(a, b)
+			x, y, prec = findFrac(a, b, 54)
 		} else {
 			a := big.NewInt(10)
 			a = a.Exp(a, big.NewInt(int64(-q)), nil)
 			b := big.NewInt(1)
 			b = b.Lsh(b, uint(e-1))
-			x, y, prec = findFrac(b, a)
+			x, y, prec = findFrac(b, a, 54)
 		}
 
 		if bits.Len64(y) == 54 {
 			f := math.Ldexp(float64(y>>1), e)
-			_ = fmt.Sprintf("f=ldexp(%d,%d)=%v, f+=(%d+%.3e)e%d\n",
+			fmt.Printf("f=ldexp(%d,%d)=%v, f+=(%d+%.3e)e%d\n",
 				y>>1, e, f, x, prec, -q)
 			hards = append(hards, f)
 		}
+
+		if e == -1074 {
+			for bitlen := 30; bitlen < 54; bitlen++ {
+				// also find hard denormals
+				a := big.NewInt(10)
+				a = a.Exp(a, big.NewInt(int64(q)), nil)
+				b := big.NewInt(1)
+				b = b.Lsh(b, uint(-(e - 1)))
+				x, y, prec = findFrac(a, b, bitlen)
+
+				f := math.Ldexp(float64(y>>1), e)
+				fmt.Printf("f=ldexp(%d,%d)=%v, f+=(%d+%.3e)e%d\n",
+					y>>1, e, f, x, prec, -q)
+				hards = append(hards, f)
+			}
+		}
 	}
 	return hards
 }
 
 // findFrac returns a fraction x/y very close to u/v,
 // such that y*(u/v) = x+prec
-func findFrac(u, v *big.Int) (x, y uint64, prec float64) {
+func findFrac(u, v *big.Int, bitlen int) (x, y uint64, prec float64) {
 	q := new(big.Rat).SetFrac(u, v)
 	for seed := uint64(1); seed < 90; seed += 3 {
-		x, y = contFrac(u, v, seed)
-		if bits.Len64(y) == 54 && y%2 == 1 && x%10 == 0 {
+		x, y = contFrac(u, v, seed, 1<<uint(bitlen-1))
+		if bits.Len64(y) == bitlen && y%2 == 1 && x%10 == 0 {
 			break
 		}
 	}
@@ -86,10 +102,10 @@ func findFrac(u, v *big.Int) (x, y uint64, prec float64) {
 	return x, y, prec
 }
 
-func contFrac(u, v *big.Int, seed uint64) (x, y uint64) {
+func contFrac(u, v *big.Int, seed uint64, max uint64) (x, y uint64) {
 	var a, b uint64 = 1, 0
 	var c, d uint64 = 0, seed
-	for c < 1<<53 {
+	for c < max {
 		if v.BitLen() == 0 {
 			break
 		}
@@ -107,6 +123,10 @@ func contFrac(u, v *big.Int, seed uint64) (x, y uint64) {
 }
 
 var hardFloatSamples = []float64{
+	// Denormals
+	math.Ldexp(328742302, -1074),
+	math.Ldexp(1845284427387, -1074),
+	math.Ldexp(341076211242912, -1074),
 	// Difficulty < 1e-15
 	math.Ldexp(6417092537094053, -748),
 	math.Ldexp(7675932596762664, -653),