Integrating fast_float to optionally replace strtod (#1260)

Fast_float is a C++ header-only library to parse doubles using SIMD instructions. The purpose is to speed up sorted sets and other commands that use doubles. A single-file copy of fast_float is included in this repo. This introduces an optional dependency on a C++ compiler. The use of fast_float is enabled at compile time using the make variable `USE_FAST_FLOAT=yes`. It is disabled by default. Fixes #1069. --------- Signed-off-by: Parth Patel <661497+parthpatel@users.noreply.github.com> Signed-off-by: Parth <661497+parthpatel@users.noreply.github.com> Signed-off-by: Madelyn Olson <madelyneolson@gmail.com> Signed-off-by: Viktor Söderqvist <viktor.soderqvist@est.tech> Co-authored-by: Roshan Swain <swainroshan001@gmail.com> Co-authored-by: Madelyn Olson <madelyneolson@gmail.com> Co-authored-by: Viktor Söderqvist <viktor.soderqvist@est.tech>
2024-11-25 01:01:43 -08:00 · 2024-11-25 01:01:43 -08:00 · c4920bca4a
commit c4920bca4a
parent 653d5f7fe3
18 changed files with 4136 additions and 29 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -17,7 +17,7 @@ jobs:
      - name: make
        # Fail build if there are warnings
        # build with TLS just for compilation coverage
-        run: make -j4 all-with-unit-tests SERVER_CFLAGS='-Werror' BUILD_TLS=yes
+        run: make -j4 all-with-unit-tests SERVER_CFLAGS='-Werror' BUILD_TLS=yes USE_FAST_FLOAT=yes
      - name: test
        run: |
          sudo apt-get install tcl8.6 tclx
@ -108,23 +108,30 @@ jobs:
    steps:
      - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
      - name: make
-        run: make -j3 all-with-unit-tests SERVER_CFLAGS='-Werror'
+        # Build with additional upcoming features
+        run: make -j3 all-with-unit-tests SERVER_CFLAGS='-Werror' USE_FAST_FLOAT=yes

  build-32bit:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
      - name: make
+        # Fast float requires C++ 32-bit libraries to compile on 64-bit ubuntu
+        # machine i.e. "-cross" suffixed version. Cross-compiling c++ to 32-bit
+        # also requires multilib support for g++ compiler i.e. "-multilib"
+        # suffixed version of g++. g++-multilib generally includes libstdc++.
+        # *cross version as well, but it is also added explicitly just in case.
        run: |
-          sudo apt-get update && sudo apt-get install libc6-dev-i386
-          make -j4 SERVER_CFLAGS='-Werror' 32bit
+          sudo apt-get update
+          sudo apt-get install libc6-dev-i386 libstdc++-11-dev-i386-cross gcc-multilib g++-multilib
+          make -j4 SERVER_CFLAGS='-Werror' 32bit USE_FAST_FLOAT=yes

  build-libc-malloc:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
      - name: make
-        run: make -j4 SERVER_CFLAGS='-Werror' MALLOC=libc
+        run: make -j4 SERVER_CFLAGS='-Werror' MALLOC=libc USE_FAST_FLOAT=yes

  build-almalinux8-jemalloc:
    runs-on: ubuntu-latest
@ -134,8 +141,8 @@ jobs:

      - name: make
        run: |
-          dnf -y install epel-release gcc make procps-ng which
-          make -j4 SERVER_CFLAGS='-Werror'
+          dnf -y install epel-release gcc gcc-c++ make procps-ng which
+          make -j4 SERVER_CFLAGS='-Werror' USE_FAST_FLOAT=yes

  format-yaml:
    runs-on: ubuntu-latest
--- a/.github/workflows/daily.yml
+++ b/.github/workflows/daily.yml
@ -319,7 +319,7 @@ jobs:
          ref: ${{ env.GITHUB_HEAD_REF }}
      - name: make
        run: |
-          make BUILD_TLS=yes SERVER_CFLAGS='-Werror'
+          make BUILD_TLS=yes SERVER_CFLAGS='-Werror' USE_FAST_FLOAT=yes
      - name: testprep
        run: |
          sudo apt-get install tcl8.6 tclx tcl-tls
--- a/deps/Makefile
+++ b/deps/Makefile
@ -42,6 +42,7 @@ distclean:
 	-(cd jemalloc && [ -f Makefile ] && $(MAKE) distclean) > /dev/null || true
 	-(cd hdr_histogram && $(MAKE) clean) > /dev/null || true
 	-(cd fpconv && $(MAKE) clean) > /dev/null || true
+	-(cd fast_float_c_interface && $(MAKE) clean) > /dev/null || true
 	-(rm -f .make-*)

 .PHONY: distclean
@ -116,3 +117,9 @@ jemalloc: .make-prerequisites
 	cd jemalloc && $(MAKE) lib/libjemalloc.a

 .PHONY: jemalloc
+
+fast_float_c_interface: .make-prerequisites
+	@printf '%b %b\n' $(MAKECOLOR)MAKE$(ENDCOLOR) $(BINCOLOR)$@$(ENDCOLOR)
+	cd fast_float_c_interface && $(MAKE)
+
+.PHONY: fast_float_c_interface
--- a/deps/README.md
+++ b/deps/README.md
@ -6,6 +6,7 @@ should be provided by the operating system.
 * **linenoise** is a readline replacement. It is developed by the same authors of Valkey but is managed as a separated project and updated as needed.
 * **lua** is Lua 5.1 with minor changes for security and additional libraries.
 * **hdr_histogram** Used for per-command latency tracking histograms.
+* **fast_float** is a replacement for strtod to convert strings to floats efficiently. 

 How to upgrade the above dependencies
 ===
@ -105,3 +106,17 @@ We use a customized version based on master branch commit e4448cf6d1cd08fff51981
 2. Copy updated files from newer version onto files in /hdr_histogram.
 3. Apply the changes from 1 above to the updated files.

+fast_float
+---
+The fast_float library provides fast header-only implementations for the C++ from_chars functions for `float` and `double` types as well as integer types.  These functions convert ASCII strings representing decimal values (e.g., `1.3e10`) into binary types. The functions are much faster than comparable number-parsing functions from existing C++ standard libraries.
+
+Specifically, `fast_float` provides the following function to parse floating-point numbers with a C++17-like syntax (the library itself only requires C++11):
+
+    template <typename T, typename UC = char, typename = FASTFLOAT_ENABLE_IF(is_supported_float_type<T>())>
+    from_chars_result_t<UC> from_chars(UC const *first, UC const *last, T &value, chars_format fmt = chars_format::general);
+
+To upgrade the library,
+1. Check out https://github.com/fastfloat/fast_float/tree/main
+2. cd fast_float
+3. Invoke "python3 ./script/amalgamate.py --output fast_float.h"
+4. Copy fast_float.h file to "deps/fast_float/".
--- a/deps/fast_float/fast_float.h
+++ b/deps/fast_float/fast_float.h
--- a/deps/fast_float_c_interface/Makefile
+++ b/deps/fast_float_c_interface/Makefile
@ -0,0 +1,37 @@
+CCCOLOR:="\033[34m"
+SRCCOLOR:="\033[33m"
+ENDCOLOR:="\033[0m"
+
+CXX?=c++
+# we need = instead of := so that $@ in QUIET_CXX gets evaluated in the rule and is assigned appropriate value.
+TEMP:=$(CXX)
+QUIET_CXX=@printf '    %b %b\n' $(CCCOLOR)C++$(ENDCOLOR) $(SRCCOLOR)$@$(ENDCOLOR) 1>&2;
+CXX=$(QUIET_CXX)$(TEMP)
+
+WARN=-Wall -W -Wno-missing-field-initializers
+
+STD=-pedantic -std=c++11
+
+OPT?=-O3
+CLANG := $(findstring clang,$(shell sh -c '$(CC) --version | head -1'))
+ifeq ($(OPT),-O3)
+        ifeq (clang,$(CLANG))
+                OPT+=-flto
+        else
+                OPT+=-flto=auto -ffat-lto-objects
+        endif
+endif
+
+# 1) Today src/Makefile passes -m32 flag for explicit 32-bit build on 64-bit machine, via CFLAGS. For 32-bit build on
+# 32-bit machine and 64-bit on 64-bit machine, CFLAGS are empty. No other flags are set that can conflict with C++,
+# therefore let's use CFLAGS without changes for now.
+# 2) FASTFLOAT_ALLOWS_LEADING_PLUS allows +inf to be parsed as inf, instead of error.
+CXXFLAGS=$(STD) $(OPT) $(WARN) -static -fPIC -fno-exceptions $(CFLAGS) -D FASTFLOAT_ALLOWS_LEADING_PLUS 
+
+.PHONY: all clean
+
+all: fast_float_strtod.o
+
+clean:
+	rm -f *.o || true;
+
--- a/deps/fast_float_c_interface/fast_float_strtod.cpp
+++ b/deps/fast_float_c_interface/fast_float_strtod.cpp
@ -0,0 +1,24 @@
+/*
+ * Copyright Valkey Contributors.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD 3-Clause
+ */
+
+#include "../fast_float/fast_float.h"
+#include <cerrno>
+
+extern "C"
+{
+    double fast_float_strtod(const char *str, const char** endptr)
+    {
+        double temp = 0;
+        auto answer = fast_float::from_chars(str, str + strlen(str), temp);
+        if (answer.ec != std::errc()) {
+            errno = (answer.ec == std::errc::result_out_of_range) ? ERANGE : EINVAL;
+        }
+        if (endptr) {
+            *endptr = answer.ptr;
+        }
+        return temp;
+    }
+}
--- a/src/Makefile
+++ b/src/Makefile
@ -424,6 +424,17 @@ ENGINE_TEST_OBJ:=$(sort $(patsubst unit/%.c,unit/%.o,$(ENGINE_TEST_FILES)))
 ENGINE_UNIT_TESTS:=$(ENGINE_NAME)-unit-tests$(PROG_SUFFIX)
 ALL_SOURCES=$(sort $(patsubst %.o,%.c,$(ENGINE_SERVER_OBJ) $(ENGINE_CLI_OBJ) $(ENGINE_BENCHMARK_OBJ)))

+USE_FAST_FLOAT?=no
+ifeq ($(USE_FAST_FLOAT),yes)
+	# valkey_strtod.h uses this flag to switch valkey_strtod function to fast_float_strtod,
+	# therefore let's pass it to compiler for preprocessing.
+	FINAL_CFLAGS += -D USE_FAST_FLOAT
+	# next, let's build and add actual library containing fast_float_strtod function for linking.
+	DEPENDENCY_TARGETS += fast_float_c_interface
+	FAST_FLOAT_STRTOD_OBJECT := ../deps/fast_float_c_interface/fast_float_strtod.o
+	FINAL_LIBS += $(FAST_FLOAT_STRTOD_OBJECT)
+endif
+
 all: $(SERVER_NAME) $(ENGINE_SENTINEL_NAME) $(ENGINE_CLI_NAME) $(ENGINE_BENCHMARK_NAME) $(ENGINE_CHECK_RDB_NAME) $(ENGINE_CHECK_AOF_NAME) $(TLS_MODULE) $(RDMA_MODULE)
 	@echo ""
 	@echo "Hint: It's a good idea to run 'make test' ;)"
@ -588,7 +599,7 @@ bench: $(ENGINE_BENCHMARK_NAME)

 32bit:
 	@echo ""
-	@echo "WARNING: if it fails under Linux you probably need to install libc6-dev-i386"
+	@echo "WARNING: if it fails under Linux you probably need to install libc6-dev-i386 and libstdc++-11-dev-i386-cross"
 	@echo ""
 	$(MAKE) all-with-unit-tests CFLAGS="-m32" LDFLAGS="-m32"

--- a/src/debug.c
+++ b/src/debug.c
@ -46,6 +46,8 @@
 #include <sys/mman.h>
 #include <unistd.h>

+#include "valkey_strtod.h"
+
 #ifdef HAVE_BACKTRACE
 #include <execinfo.h>
 #ifndef __OpenBSD__
@ -846,7 +848,7 @@ void debugCommand(client *c) {
                             "string|integer|double|bignum|null|array|set|map|attrib|push|verbatim|true|false");
        }
    } else if (!strcasecmp(c->argv[1]->ptr, "sleep") && c->argc == 3) {
-        double dtime = strtod(c->argv[2]->ptr, NULL);
+        double dtime = valkey_strtod(c->argv[2]->ptr, NULL);
        long long utime = dtime * 1000000;
        struct timespec tv;

--- a/src/resp_parser.c
+++ b/src/resp_parser.c
@ -58,6 +58,8 @@
 #include "resp_parser.h"
 #include "server.h"

+#include "valkey_strtod.h"
+
 static int parseBulk(ReplyParser *parser, void *p_ctx) {
    const char *proto = parser->curr_location;
    char *p = strchr(proto + 1, '\r');
@ -150,13 +152,11 @@ static int parseDouble(ReplyParser *parser, void *p_ctx) {
    parser->curr_location = p + 2; /* for \r\n */
    char buf[MAX_LONG_DOUBLE_CHARS + 1];
    size_t len = p - proto - 1;
-    double d;
+    double d = 0;
    if (len <= MAX_LONG_DOUBLE_CHARS) {
        memcpy(buf, proto + 1, len);
        buf[len] = '\0';
-        d = strtod(buf, NULL); /* We expect a valid representation. */
-    } else {
-        d = 0;
+        d = valkey_strtod(buf, NULL); /* We expect a valid representation. */
    }
    parser->callbacks.double_callback(p_ctx, d, proto, parser->curr_location - proto);
    return C_OK;
--- a/src/sort.c
+++ b/src/sort.c
@ -34,6 +34,8 @@
 #include <math.h>   /* isnan() */
 #include "cluster.h"

+#include "valkey_strtod.h"
+
 zskiplistNode *zslGetElementByRank(zskiplist *zsl, unsigned long rank);

 serverSortOperation *createSortOperation(int type, robj *pattern) {
@ -479,9 +481,9 @@ void sortCommandGeneric(client *c, int readonly) {
            } else {
                if (sdsEncodedObject(byval)) {
                    char *eptr;
-
-                    vector[j].u.score = strtod(byval->ptr, &eptr);
-                    if (eptr[0] != '\0' || errno == ERANGE || isnan(vector[j].u.score)) {
+                    errno = 0;
+                    vector[j].u.score = valkey_strtod(byval->ptr, &eptr);
+                    if (eptr[0] != '\0' || errno == ERANGE || errno == EINVAL || isnan(vector[j].u.score)) {
                        int_conversion_error = 1;
                    }
                } else if (byval->encoding == OBJ_ENCODING_INT) {
--- a/src/t_zset.c
+++ b/src/t_zset.c
@ -60,6 +60,8 @@
 #include "intset.h" /* Compact integer set structure */
 #include <math.h>

+#include "valkey_strtod.h"
+
 /*-----------------------------------------------------------------------------
 * Skiplist implementation of the low level API
 *----------------------------------------------------------------------------*/
@ -546,11 +548,11 @@ static int zslParseRange(robj *min, robj *max, zrangespec *spec) {
        spec->min = (long)min->ptr;
    } else {
        if (((char *)min->ptr)[0] == '(') {
-            spec->min = strtod((char *)min->ptr + 1, &eptr);
+            spec->min = valkey_strtod((char *)min->ptr + 1, &eptr);
            if (eptr[0] != '\0' || isnan(spec->min)) return C_ERR;
            spec->minex = 1;
        } else {
-            spec->min = strtod((char *)min->ptr, &eptr);
+            spec->min = valkey_strtod((char *)min->ptr, &eptr);
            if (eptr[0] != '\0' || isnan(spec->min)) return C_ERR;
        }
    }
@ -558,11 +560,11 @@ static int zslParseRange(robj *min, robj *max, zrangespec *spec) {
        spec->max = (long)max->ptr;
    } else {
        if (((char *)max->ptr)[0] == '(') {
-            spec->max = strtod((char *)max->ptr + 1, &eptr);
+            spec->max = valkey_strtod((char *)max->ptr + 1, &eptr);
            if (eptr[0] != '\0' || isnan(spec->max)) return C_ERR;
            spec->maxex = 1;
        } else {
-            spec->max = strtod((char *)max->ptr, &eptr);
+            spec->max = valkey_strtod((char *)max->ptr, &eptr);
            if (eptr[0] != '\0' || isnan(spec->max)) return C_ERR;
        }
    }
@ -757,7 +759,7 @@ double zzlStrtod(unsigned char *vstr, unsigned int vlen) {
    if (vlen > sizeof(buf) - 1) vlen = sizeof(buf) - 1;
    memcpy(buf, vstr, vlen);
    buf[vlen] = '\0';
-    return strtod(buf, NULL);
+    return valkey_strtod(buf, NULL);
 }

 double zzlGetScore(unsigned char *sptr) {
--- a/src/unit/test_files.h
+++ b/src/unit/test_files.h
@ -166,6 +166,7 @@ int test_ld2string(int argc, char **argv, int flags);
 int test_fixedpoint_d2string(int argc, char **argv, int flags);
 int test_version2num(int argc, char **argv, int flags);
 int test_reclaimFilePageCache(int argc, char **argv, int flags);
+int test_valkey_strtod(int argc, char **argv, int flags);
 int test_ziplistCreateIntList(int argc, char **argv, int flags);
 int test_ziplistPop(int argc, char **argv, int flags);
 int test_ziplistGetElementAtIndex3(int argc, char **argv, int flags);
@ -220,6 +221,7 @@ unitTest __test_rax_c[] = {{"test_raxRandomWalk", test_raxRandomWalk}, {"test_ra
 unitTest __test_sds_c[] = {{"test_sds", test_sds}, {"test_typesAndAllocSize", test_typesAndAllocSize}, {"test_sdsHeaderSizes", test_sdsHeaderSizes}, {"test_sdssplitargs", test_sdssplitargs}, {NULL, NULL}};
 unitTest __test_sha1_c[] = {{"test_sha1", test_sha1}, {NULL, NULL}};
 unitTest __test_util_c[] = {{"test_string2ll", test_string2ll}, {"test_string2l", test_string2l}, {"test_ll2string", test_ll2string}, {"test_ld2string", test_ld2string}, {"test_fixedpoint_d2string", test_fixedpoint_d2string}, {"test_version2num", test_version2num}, {"test_reclaimFilePageCache", test_reclaimFilePageCache}, {NULL, NULL}};
+unitTest __test_valkey_strtod_c[] = {{"test_valkey_strtod", test_valkey_strtod}, {NULL, NULL}};
 unitTest __test_ziplist_c[] = {{"test_ziplistCreateIntList", test_ziplistCreateIntList}, {"test_ziplistPop", test_ziplistPop}, {"test_ziplistGetElementAtIndex3", test_ziplistGetElementAtIndex3}, {"test_ziplistGetElementOutOfRange", test_ziplistGetElementOutOfRange}, {"test_ziplistGetLastElement", test_ziplistGetLastElement}, {"test_ziplistGetFirstElement", test_ziplistGetFirstElement}, {"test_ziplistGetElementOutOfRangeReverse", test_ziplistGetElementOutOfRangeReverse}, {"test_ziplistIterateThroughFullList", test_ziplistIterateThroughFullList}, {"test_ziplistIterateThroughListFrom1ToEnd", test_ziplistIterateThroughListFrom1ToEnd}, {"test_ziplistIterateThroughListFrom2ToEnd", test_ziplistIterateThroughListFrom2ToEnd}, {"test_ziplistIterateThroughStartOutOfRange", test_ziplistIterateThroughStartOutOfRange}, {"test_ziplistIterateBackToFront", test_ziplistIterateBackToFront}, {"test_ziplistIterateBackToFrontDeletingAllItems", test_ziplistIterateBackToFrontDeletingAllItems}, {"test_ziplistDeleteInclusiveRange0To0", test_ziplistDeleteInclusiveRange0To0}, {"test_ziplistDeleteInclusiveRange0To1", test_ziplistDeleteInclusiveRange0To1}, {"test_ziplistDeleteInclusiveRange1To2", test_ziplistDeleteInclusiveRange1To2}, {"test_ziplistDeleteWithStartIndexOutOfRange", test_ziplistDeleteWithStartIndexOutOfRange}, {"test_ziplistDeleteWithNumOverflow", test_ziplistDeleteWithNumOverflow}, {"test_ziplistDeleteFooWhileIterating", test_ziplistDeleteFooWhileIterating}, {"test_ziplistReplaceWithSameSize", test_ziplistReplaceWithSameSize}, {"test_ziplistReplaceWithDifferentSize", test_ziplistReplaceWithDifferentSize}, {"test_ziplistRegressionTestForOver255ByteStrings", test_ziplistRegressionTestForOver255ByteStrings}, {"test_ziplistRegressionTestDeleteNextToLastEntries", test_ziplistRegressionTestDeleteNextToLastEntries}, {"test_ziplistCreateLongListAndCheckIndices", test_ziplistCreateLongListAndCheckIndices}, {"test_ziplistCompareStringWithZiplistEntries", test_ziplistCompareStringWithZiplistEntries}, {"test_ziplistMergeTest", test_ziplistMergeTest}, {"test_ziplistStressWithRandomPayloadsOfDifferentEncoding", test_ziplistStressWithRandomPayloadsOfDifferentEncoding}, {"test_ziplistCascadeUpdateEdgeCases", test_ziplistCascadeUpdateEdgeCases}, {"test_ziplistInsertEdgeCase", test_ziplistInsertEdgeCase}, {"test_ziplistStressWithVariableSize", test_ziplistStressWithVariableSize}, {"test_BenchmarkziplistFind", test_BenchmarkziplistFind}, {"test_BenchmarkziplistIndex", test_BenchmarkziplistIndex}, {"test_BenchmarkziplistValidateIntegrity", test_BenchmarkziplistValidateIntegrity}, {"test_BenchmarkziplistCompareWithString", test_BenchmarkziplistCompareWithString}, {"test_BenchmarkziplistCompareWithNumber", test_BenchmarkziplistCompareWithNumber}, {"test_ziplistStress__ziplistCascadeUpdate", test_ziplistStress__ziplistCascadeUpdate}, {NULL, NULL}};
 unitTest __test_zipmap_c[] = {{"test_zipmapIterateWithLargeKey", test_zipmapIterateWithLargeKey}, {"test_zipmapIterateThroughElements", test_zipmapIterateThroughElements}, {NULL, NULL}};
 unitTest __test_zmalloc_c[] = {{"test_zmallocInitialUsedMemory", test_zmallocInitialUsedMemory}, {"test_zmallocAllocReallocCallocAndFree", test_zmallocAllocReallocCallocAndFree}, {"test_zmallocAllocZeroByteAndFree", test_zmallocAllocZeroByteAndFree}, {NULL, NULL}};
@ -240,6 +242,7 @@ struct unitTestSuite {
    {"test_sds.c", __test_sds_c},
    {"test_sha1.c", __test_sha1_c},
    {"test_util.c", __test_util_c},
+    {"test_valkey_strtod.c", __test_valkey_strtod_c},
    {"test_ziplist.c", __test_ziplist_c},
    {"test_zipmap.c", __test_zipmap_c},
    {"test_zmalloc.c", __test_zmalloc_c},
--- a/src/unit/test_valkey_strtod.c
+++ b/src/unit/test_valkey_strtod.c
@ -0,0 +1,36 @@
+/*
+ * Copyright Valkey Contributors.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD 3-Clause
+ */
+
+
+#include "../valkey_strtod.h"
+#include "errno.h"
+#include "math.h"
+#include "test_help.h"
+
+int test_valkey_strtod(int argc, char **argv, int flags) {
+    UNUSED(argc);
+    UNUSED(argv);
+    UNUSED(flags);
+
+    errno = 0;
+    double value = valkey_strtod("231.2341234", NULL);
+    TEST_ASSERT(value == 231.2341234);
+    TEST_ASSERT(errno == 0);
+
+    value = valkey_strtod("+inf", NULL);
+    TEST_ASSERT(isinf(value));
+    TEST_ASSERT(errno == 0);
+
+    value = valkey_strtod("-inf", NULL);
+    TEST_ASSERT(isinf(value));
+    TEST_ASSERT(errno == 0);
+
+    value = valkey_strtod("inf", NULL);
+    TEST_ASSERT(isinf(value));
+    TEST_ASSERT(errno == 0);
+
+    return 0;
+}
--- a/src/util.c
+++ b/src/util.c
@ -51,6 +51,8 @@
 #include "sha256.h"
 #include "config.h"

+#include "valkey_strtod.h"
+
 #define UNUSED(x) ((void)(x))

 /* Glob-style pattern matching. */
@ -595,10 +597,12 @@ int string2ld(const char *s, size_t slen, long double *dp) {
 int string2d(const char *s, size_t slen, double *dp) {
    errno = 0;
    char *eptr;
-    *dp = strtod(s, &eptr);
+    *dp = valkey_strtod(s, &eptr);
    if (slen == 0 || isspace(((const char *)s)[0]) || (size_t)(eptr - (char *)s) != slen ||
-        (errno == ERANGE && (*dp == HUGE_VAL || *dp == -HUGE_VAL || fpclassify(*dp) == FP_ZERO)) || isnan(*dp))
+        (errno == ERANGE && (*dp == HUGE_VAL || *dp == -HUGE_VAL || fpclassify(*dp) == FP_ZERO)) || isnan(*dp) || errno == EINVAL) {
+        errno = 0;
        return 0;
+    }
    return 1;
 }

--- a/src/valkey-cli.c
+++ b/src/valkey-cli.c
@ -65,6 +65,8 @@
 #include "mt19937-64.h"
 #include "cli_commands.h"

+#include "valkey_strtod.h"
+
 #define UNUSED(V) ((void)V)

 #define OUTPUT_STANDARD 0
@ -2537,9 +2539,10 @@ static int parseOptions(int argc, char **argv) {
                exit(1);
            }
        } else if (!strcmp(argv[i], "-t") && !lastarg) {
+            errno = 0;
            char *eptr;
-            double seconds = strtod(argv[++i], &eptr);
-            if (eptr[0] != '\0' || isnan(seconds) || seconds < 0.0) {
+            double seconds = valkey_strtod(argv[++i], &eptr);
+            if (eptr[0] != '\0' || isnan(seconds) || seconds < 0.0 || errno == EINVAL || errno == ERANGE) {
                fprintf(stderr, "Invalid connection timeout for -t.\n");
                exit(1);
            }
--- a/src/valkey_strtod.h
+++ b/src/valkey_strtod.h
@ -0,0 +1,42 @@
+#ifndef FAST_FLOAT_STRTOD_H
+#define FAST_FLOAT_STRTOD_H
+
+#ifdef USE_FAST_FLOAT
+
+#include "errno.h"
+
+/**
+ * Converts a null-terminated byte string to a double using the fast_float library.
+ *
+ * This function provides a C-compatible wrapper around the fast_float library's string-to-double
+ * conversion functionality. It aims to offer a faster alternative to the standard strtod function.
+ *
+ * str: A pointer to the null-terminated byte string to be converted.
+ * eptr: On success, stores char pointer pointing to '\0' at the end of the string.
+ *       On failure, stores char pointer pointing to first invalid character in the string.
+ * returns: On success, the function returns the converted double value.
+ *          On failure, it returns 0.0 and stores error code in errno to ERANGE or EINVAL.
+ *
+ * note: This function uses the fast_float library (https://github.com/fastfloat/fast_float) for
+ * the actual conversion, which can be significantly faster than standard library functions.
+ * Refer to "../deps/fast_float_c_interface" for more details.
+ * Refer to https://github.com/fastfloat/fast_float for more information on the underlying library.
+ */
+double fast_float_strtod(const char *str, char **endptr);
+
+static inline double valkey_strtod(const char *str, char **endptr) {
+    errno = 0;
+    return fast_float_strtod(str, endptr);
+}
+
+#else
+
+#include <stdlib.h>
+
+static inline double valkey_strtod(const char *str, char **endptr) {
+    return strtod(str, endptr);
+}
+
+#endif
+
+#endif // FAST_FLOAT_STRTOD_H
--- a/tests/test_helper.tcl
+++ b/tests/test_helper.tcl
@ -35,12 +35,12 @@ foreach test_dir $test_dirs {

 set cluster_test_dir unit/cluster
 foreach file [glob -nocomplain $dir/tests/$cluster_test_dir/*.tcl] {
-   lappend ::cluster_all_tests $cluster_test_dir/[file root [file tail $file]]
+    lappend ::cluster_all_tests $cluster_test_dir/[file root [file tail $file]]
 }

 set moduleapi_test_dir unit/moduleapi
 foreach file [glob -nocomplain $dir/tests/$moduleapi_test_dir/*.tcl] {
-   lappend ::module_api_all_tests $moduleapi_test_dir/[file root [file tail $file]]
+    lappend ::module_api_all_tests $moduleapi_test_dir/[file root [file tail $file]]
 }

 # Index to the next test to run in the ::all_tests list.
@ -654,7 +654,7 @@ for {set j 0} {$j < [llength $argv]} {incr j} {
        }
    } elseif {$opt eq {--quiet}} {
        set ::quiet 1
-   } elseif {$opt eq {--io-threads}} {
+    } elseif {$opt eq {--io-threads}} {
        set ::io_threads 1
    } elseif {$opt eq {--tls} || $opt eq {--tls-module}} {
        package require tls 1.6