Improve performance of ParseUfloat

bytesconv.go

@@ -8,7 +8,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"math"
 	"net"
 	"strconv"
 	"sync"
@@ -172,61 +171,19 @@ func parseUintBuf(b []byte) (int, int, error) {
 	return v, n, nil
 }
 
-var (
-	errEmptyFloat           = errors.New("empty float number")
-	errDuplicateFloatPoint  = errors.New("duplicate point found in float number")
-	errUnexpectedFloatEnd   = errors.New("unexpected end of float number")
-	errInvalidFloatExponent = errors.New("invalid float number exponent")
-	errUnexpectedFloatChar  = errors.New("unexpected char found in float number")
-)
-
 // ParseUfloat parses unsigned float from buf.
 func ParseUfloat(buf []byte) (float64, error) {
-	if len(buf) == 0 {
-		return -1, errEmptyFloat
+	// The implementation of parsing a float string is not easy.
+	// We believe that the conservative approach is to call strconv.ParseFloat.
+	// https://github.com/valyala/fasthttp/pull/1865
+	res, err := strconv.ParseFloat(b2s(buf), 64)
+	if res < 0 {
+		return -1, errors.New("negative input is invalid")
 	}
-	b := buf
-	var v uint64
-	offset := 1.0
-	var pointFound bool
-	for i, c := range b {
-		if c < '0' || c > '9' {
-			if c == '.' {
-				if pointFound {
-					return -1, errDuplicateFloatPoint
-				}
-				pointFound = true
-				continue
-			}
-			if c == 'e' || c == 'E' {
-				if i+1 >= len(b) {
-					return -1, errUnexpectedFloatEnd
-				}
-				b = b[i+1:]
-				minus := -1
-				switch b[0] {
-				case '+':
-					b = b[1:]
-					minus = 1
-				case '-':
-					b = b[1:]
-				default:
-					minus = 1
-				}
-				vv, err := ParseUint(b)
-				if err != nil {
-					return -1, errInvalidFloatExponent
-				}
-				return float64(v) * offset * math.Pow10(minus*vv), nil
-			}
-			return -1, errUnexpectedFloatChar
-		}
-		v = 10*v + uint64(c-'0')
-		if pointFound {
-			offset /= 10
-		}
+	if err != nil {
+		return -1, err
 	}
-	return float64(v) * offset, nil
+	return res, err
 }
 
 var (

bytesconv_test.go

@@ -234,6 +234,12 @@ func TestParseUfloatSuccess(t *testing.T) {
 	testParseUfloatSuccess(t, "1234e2", 1234e2)
 	testParseUfloatSuccess(t, "1234E-5", 1234e-5)
 	testParseUfloatSuccess(t, "1.234e+3", 1.234e+3)
+	testParseUfloatSuccess(t, "1234e23", 1234e23)
+	testParseUfloatSuccess(t, "1.234e+32", 1.234e+32)
+	testParseUfloatSuccess(t, "123456789123456789.987654321", 123456789123456789.987654321)
+	testParseUfloatSuccess(t, "1.23456789123456789987654321", 1.23456789123456789987654321)
+	testParseUfloatSuccess(t, "340282346638528859811704183484516925440", 340282346638528859811704183484516925440)
+	testParseUfloatSuccess(t, "00000000000000000001", 1)
 }
 
 func TestParseUfloatError(t *testing.T) {
@@ -263,6 +269,10 @@ func TestParseUfloatError(t *testing.T) {
 
 	// missing exponent
 	testParseUfloatError(t, "123534e")
+
+	// negative number
+	testParseUfloatError(t, "-1")
+	testParseUfloatError(t, "-Inf")
 }
 
 func testParseUfloatError(t *testing.T, s string) {

bytesconv_timing_test.go

@@ -163,3 +163,27 @@ func BenchmarkAppendUnquotedArgSlowPath(b *testing.B) {
 		}
 	})
 }
+
+func BenchmarkParseUfloat(b *testing.B) {
+	src := [][]byte{
+		[]byte("0"),
+		[]byte("1234566789."),
+		[]byte(".1234556778"),
+		[]byte("123.456"),
+		[]byte("123456789"),
+		[]byte("1234e23"),
+		[]byte("1234E-51"),
+		[]byte("1.234e+32"),
+		[]byte("123456789123456789.987654321"),
+	}
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			for i := range src {
+				_, err := ParseUfloat(src[i])
+				if err != nil {
+					b.Fatalf("unexpected error: %v", err)
+				}
+			}
+		}
+	})
+}