Improwing speed and reduce code size when fast_float is using as internal parser code.

.github/workflows/vs17-ci.yml

@@ -11,7 +11,7 @@ jobs:
       matrix:
         include:
           - {gen: Visual Studio 17 2022, arch: Win32, cfg: Release}
-          #- {gen: Visual Studio 17 2022, arch: Win32, cfg: Debug}
+          - {gen: Visual Studio 17 2022, arch: Win32, cfg: Debug}
           - {gen: Visual Studio 17 2022, arch: x64, cfg: Release}
           - {gen: Visual Studio 17 2022, arch: x64, cfg: Debug}
     steps:

CONTRIBUTORS

@@ -9,3 +9,4 @@ Jan Pharago
 Maya Warrier
 Taha Khokhar
 Anders Dalvander
+Elle Solomina

README.md

@@ -357,6 +357,47 @@ int main() {
 }
 ```
 
+You also can use not standard options:
+
+```C++
+#include "fast_float/fast_float.h"
+#include <iostream>
+
+int main() {
+  std::string input = "      +456";
+  double result;
+  fast_float::parse_options options{chars_format::allow_leading_plus | chars_format::skip_white_space};
+  auto answer = fast_float::from_chars_advanced(input.data(), input.data() + input.size(), result, options);
+  if ((answer.ec != std::errc()) || ((result != 456))) { std::cerr << "parsing failure\n"; return EXIT_FAILURE; }
+  return EXIT_SUCCESS;
+}
+```
+
+For special case scenarious, like mathematical or other AST like parcer that already process minus sign 
+and only pasre in FastFloat positive numbers in fixed, scientific or hex format and do not have inf or nan
+in input you can use macros FASTFLOAT_ONLY_POSITIVE_C_NUMBER_WO_INF_NAN that significantly reduce
+the code size and improve performance:
+
+```C++
+#define FASTFLOAT_ONLY_POSITIVE_C_NUMBER_WO_INF_NAN
+#include "fast_float/fast_float.h"
+#include <iostream>
+
+int main() {
+  std::string input = "23.14069263277926900572";
+  double result;
+  auto answer = fast_float::from_chars(input.data(), input.data() + input.size(), result);
+  if ((answer.ec != std::errc()) || ((result != 23.14069263277927 /*properly rounded value */)))
+    { std::cerr << "parsing failure\n"; return EXIT_FAILURE; }
+  input = "-23.14069263277926900572";
+  if (answer.ec == std::errc()) { std::cerr << "parsing failure, should failed on any sign\n"; return EXIT_FAILURE; }
+  input = "inf";
+  if (answer.ec == std::errc()) { std::cerr << "parsing failure, should failed on infinity\n"; return EXIT_FAILURE; }
+  input = "nan";
+  if (answer.ec == std::errc()) { std::cerr << "parsing failure, should failed on nan in input\n"; return EXIT_FAILURE; }
+  return EXIT_SUCCESS;
+}
+```
 
 ## Users and Related Work
 

benchmarks/benchmark.cpp

@@ -1,10 +1,12 @@
+
+// #define FASTFLOAT_ONLY_POSITIVE_C_NUMBER_WO_INF_NAN
+// #define FASTFLOAT_ONLY_ROUNDS_TO_NEAREST_SUPPORTED
+
 #if defined(__linux__) || (__APPLE__ && __aarch64__)
 #define USING_COUNTERS
 #endif
 #include "event_counter.h"
 #include <algorithm>
-#include "fast_float/fast_float.h"
-#include <chrono>
 #include <climits>
 #include <cmath>
 #include <cstdint>
@@ -19,29 +21,17 @@
 #include <sstream>
 #include <stdio.h>
 #include <string>
-#include <vector>
 #include <locale.h>
 
-template <typename CharT>
-double findmax_fastfloat64(std::vector<std::basic_string<CharT>> &s) {
-  double answer = 0;
-  double x = 0;
-  for (auto &st : s) {
-    auto [p, ec] = fast_float::from_chars(st.data(), st.data() + st.size(), x);
-    if (p == st.data()) {
-      throw std::runtime_error("bug in findmax_fastfloat");
-    }
-    answer = answer > x ? answer : x;
-  }
-  return answer;
-}
+#include "fast_float/fast_float.h"
 
-template <typename CharT>
-double findmax_fastfloat32(std::vector<std::basic_string<CharT>> &s) {
-  float answer = 0;
-  float x = 0;
+template <typename CharT, typename Value>
+Value findmax_fastfloat(std::vector<std::basic_string<CharT>> &s) {
+  Value answer = 0;
+  Value x = 0;
   for (auto &st : s) {
     auto [p, ec] = fast_float::from_chars(st.data(), st.data() + st.size(), x);
+
     if (p == st.data()) {
       throw std::runtime_error("bug in findmax_fastfloat");
     }
@@ -50,9 +40,10 @@ double findmax_fastfloat32(std::vector<std::basic_string<CharT>> &s) {
   return answer;
 }
 
+#ifdef USING_COUNTERS
+
 event_collector collector{};
 
-#ifdef USING_COUNTERS
 template <class T, class CharT>
 std::vector<event_count>
 time_it_ns(std::vector<std::basic_string<CharT>> &lines, T const &function,
@@ -61,7 +52,7 @@ time_it_ns(std::vector<std::basic_string<CharT>> &lines, T const &function,
   bool printed_bug = false;
   for (size_t i = 0; i < repeat; i++) {
     collector.start();
-    double ts = function(lines);
+    auto const ts = function(lines);
     if (ts == 0 && !printed_bug) {
       printf("bug\n");
       printed_bug = true;
@@ -71,7 +62,7 @@ time_it_ns(std::vector<std::basic_string<CharT>> &lines, T const &function,
   return aggregate;
 }
 
-void pretty_print(double volume, size_t number_of_floats, std::string name,
+void pretty_print(size_t volume, size_t number_of_floats, std::string name,
                   std::vector<event_count> events) {
   double volumeMB = volume / (1024. * 1024.);
   double average_ns{0};
@@ -141,23 +132,23 @@ time_it_ns(std::vector<std::basic_string<CharT>> &lines, T const &function,
   bool printed_bug = false;
   for (size_t i = 0; i < repeat; i++) {
     t1 = std::chrono::high_resolution_clock::now();
-    double ts = function(lines);
+    auto const ts = function(lines);
     if (ts == 0 && !printed_bug) {
       printf("bug\n");
       printed_bug = true;
     }
     t2 = std::chrono::high_resolution_clock::now();
-    double dif =
-        std::chrono::duration_cast<std::chrono::nanoseconds>(t2 - t1).count();
+    double const dif = static_cast<double>(
+        std::chrono::duration_cast<std::chrono::nanoseconds>(t2 - t1).count());
     average += dif;
     min_value = min_value < dif ? min_value : dif;
   }
   average /= repeat;
   return std::make_pair(min_value, average);
 }
 
-void pretty_print(double volume, size_t number_of_floats, std::string name,
-                  std::pair<double, double> result) {
+void pretty_print(size_t volume, size_t number_of_floats,
+                  std::string const &name, std::pair<double, double> result) {
   double volumeMB = volume / (1024. * 1024.);
   printf("%-40s: %8.2f MB/s (+/- %.1f %%) ", name.data(),
          volumeMB * 1000000000 / result.first,
@@ -168,7 +159,7 @@ void pretty_print(double volume, size_t number_of_floats, std::string name,
 #endif
 
 // this is okay, all chars are ASCII
-inline std::u16string widen(std::string line) {
+inline std::u16string widen(std::string const &line) {
   std::u16string u16line;
   u16line.resize(line.size());
   for (size_t i = 0; i < line.size(); ++i) {
@@ -181,28 +172,29 @@ std::vector<std::u16string> widen(const std::vector<std::string> &lines) {
   std::vector<std::u16string> u16lines;
   u16lines.reserve(lines.size());
   for (auto const &line : lines) {
-    u16lines.push_back(widen(line));
+    u16lines.emplace_back(widen(line));
   }
   return u16lines;
 }
 
 void process(std::vector<std::string> &lines, size_t volume) {
-  size_t repeat = 1000;
+  size_t const repeat = 1000;
   double volumeMB = volume / (1024. * 1024.);
   std::cout << "ASCII volume = " << volumeMB << " MB " << std::endl;
   pretty_print(volume, lines.size(), "fastfloat (64)",
-               time_it_ns(lines, findmax_fastfloat64<char>, repeat));
+               time_it_ns(lines, findmax_fastfloat<char, double>, repeat));
   pretty_print(volume, lines.size(), "fastfloat (32)",
-               time_it_ns(lines, findmax_fastfloat32<char>, repeat));
+               time_it_ns(lines, findmax_fastfloat<char, float>, repeat));
 
   std::vector<std::u16string> lines16 = widen(lines);
   volume = 2 * volume;
   volumeMB = volume / (1024. * 1024.);
   std::cout << "UTF-16 volume = " << volumeMB << " MB " << std::endl;
-  pretty_print(volume, lines.size(), "fastfloat (64)",
-               time_it_ns(lines16, findmax_fastfloat64<char16_t>, repeat));
+  pretty_print(
+      volume, lines.size(), "fastfloat (64)",
+      time_it_ns(lines16, findmax_fastfloat<char16_t, double>, repeat));
   pretty_print(volume, lines.size(), "fastfloat (32)",
-               time_it_ns(lines16, findmax_fastfloat32<char16_t>, repeat));
+               time_it_ns(lines16, findmax_fastfloat<char16_t, float>, repeat));
 }
 
 void fileload(std::string filename) {
@@ -216,17 +208,31 @@ void fileload(std::string filename) {
   std::cout << "#### " << std::endl;
   std::string line;
   std::vector<std::string> lines;
-  lines.reserve(10000); // let us reserve plenty of memory.
+  lines.reserve(120000); // let us reserve plenty of memory.
   size_t volume = 0;
   while (getline(inputfile, line)) {
+#ifdef FASTFLOAT_ONLY_POSITIVE_C_NUMBER_WO_INF_NAN
+    if (line[0] == '-') {
+      line.erase(0, 1);
+    }
+#endif
+    lines.emplace_back(line);
     volume += line.size();
-    lines.push_back(line);
   }
   std::cout << "# read " << lines.size() << " lines " << std::endl;
   process(lines, volume);
 }
 
 int main(int argc, char **argv) {
+#ifdef FASTFLOAT_ONLY_POSITIVE_C_NUMBER_WO_INF_NAN
+  std::cout << "# FASTFLOAT_ONLY_POSITIVE_C_NUMBER_WO_INF_NAN is enabled"
+            << std::endl;
+#endif
+#ifdef FASTFLOAT_ONLY_ROUNDS_TO_NEAREST_SUPPORTED
+  std::cout << "# FASTFLOAT_ONLY_ROUNDS_TO_NEAREST_SUPPORTED is enabled"
+            << std::endl;
+#endif
+#ifdef USING_COUNTERS
   if (collector.has_events()) {
     std::cout << "# Using hardware counters" << std::endl;
   } else {
@@ -236,10 +242,12 @@ int main(int argc, char **argv) {
               << std::endl;
 #endif
   }
+#endif
   if (argc > 1) {
     fileload(argv[1]);
     return EXIT_SUCCESS;
   }
+
   fileload(std::string(BENCHMARK_DATA_DIR) + "/canada.txt");
   fileload(std::string(BENCHMARK_DATA_DIR) + "/mesh.txt");
   return EXIT_SUCCESS;

benchmarks/event_counter.h

@@ -10,7 +10,7 @@
 #include <cstring>
 
 #include <chrono>
-#include <vector>
+#include <array>
 
 #include "linux-perf-events.h"
 #ifdef __linux__
@@ -22,26 +22,28 @@
 #endif
 
 struct event_count {
+  // The types of counters (so we can read the getter more easily)
+  enum event_counter_types {
+    CPU_CYCLES = 0,
+    INSTRUCTIONS = 1,
+    BRANCHES = 2,
+    MISSED_BRANCHES = 3,
+    event_counter_types_size = 4
+  };
+
   std::chrono::duration<double> elapsed;
-  std::vector<unsigned long long> event_counts;
+  std::array<unsigned long long, event_counter_types_size> event_counts;
 
-  event_count() : elapsed(0), event_counts{0, 0, 0, 0, 0} {}
+  event_count() : elapsed(0), event_counts{0, 0, 0, 0} {}
 
-  event_count(const std::chrono::duration<double> _elapsed,
-              const std::vector<unsigned long long> _event_counts)
+  event_count(const std::chrono::duration<double> &_elapsed,
+              const std::array<unsigned long long, event_counter_types_size>
+                  &_event_counts)
       : elapsed(_elapsed), event_counts(_event_counts) {}
 
   event_count(const event_count &other)
       : elapsed(other.elapsed), event_counts(other.event_counts) {}
 
-  // The types of counters (so we can read the getter more easily)
-  enum event_counter_types {
-    CPU_CYCLES = 0,
-    INSTRUCTIONS = 1,
-    BRANCHES = 2,
-    MISSED_BRANCHES = 3
-  };
-
   double elapsed_sec() const {
     return std::chrono::duration<double>(elapsed).count();
   }
@@ -79,7 +81,6 @@ struct event_count {
                            event_counts[1] + other.event_counts[1],
                            event_counts[2] + other.event_counts[2],
                            event_counts[3] + other.event_counts[3],
-                           event_counts[4] + other.event_counts[4],
                        });
   }
 
@@ -129,7 +130,7 @@ struct event_collector {
   LinuxEvents<PERF_TYPE_HARDWARE> linux_events;
 
   event_collector()
-      : linux_events(std::vector<int>{
+      : linux_events(std::array<unsigned long long, 4>{
             PERF_COUNT_HW_CPU_CYCLES, PERF_COUNT_HW_INSTRUCTIONS,
             PERF_COUNT_HW_BRANCH_INSTRUCTIONS, // Retired branch instructions
             PERF_COUNT_HW_BRANCH_MISSES}) {}
@@ -142,7 +143,7 @@ struct event_collector {
 
   bool has_events() { return setup_performance_counters(); }
 #else
-  event_collector() {}
+  event_collector() = default;
 
   bool has_events() { return false; }
 #endif
@@ -171,7 +172,6 @@ struct event_collector {
     count.event_counts[1] = diff.instructions;
     count.event_counts[2] = diff.branches;
     count.event_counts[3] = diff.missed_branches;
-    count.event_counts[4] = 0;
 #endif
     count.elapsed = end_clock - start_clock;
     return count;

benchmarks/linux-perf-events.h

@@ -10,7 +10,7 @@
 #include <cstring> // for memset
 #include <stdexcept>
 
-#include <iostream>
+#include <array>
 #include <vector>
 
 template <int TYPE = PERF_TYPE_HARDWARE> class LinuxEvents {
@@ -22,7 +22,8 @@ template <int TYPE = PERF_TYPE_HARDWARE> class LinuxEvents {
   std::vector<uint64_t> ids{};
 
 public:
-  explicit LinuxEvents(std::vector<int> config_vec) : fd(0), working(true) {
+  explicit LinuxEvents(std::array<unsigned long long, 4> config_vec)
+      : fd(0), working(true) {
     memset(&attribs, 0, sizeof(attribs));
     attribs.type = TYPE;
     attribs.size = sizeof(attribs);
@@ -75,7 +76,7 @@ template <int TYPE = PERF_TYPE_HARDWARE> class LinuxEvents {
     }
   }
 
-  inline void end(std::vector<unsigned long long> &results) {
+  inline void end(std::array<unsigned long long, 4> &results) {
     if (fd != -1) {
       if (ioctl(fd, PERF_EVENT_IOC_DISABLE, PERF_IOC_FLAG_GROUP) == -1) {
         report_error("ioctl(PERF_EVENT_IOC_DISABLE)");