react-native-quick-crypto 1.0.18 → 1.1.0

package/deps/simdutf/benchmarks/src/cmdline.cpp

@@ -0,0 +1,176 @@
+#include "cmdline.h"
+
+#include <vector>
+#include <stdexcept>
+
+constexpr size_t DEFAULT_ITERATIONS =
+    30000; // Such a high number is helpful for stable measures.
+
+namespace {
+
+using simdutf::benchmarks::CommandLine;
+using simdutf::benchmarks::ListingMode;
+
+CommandLine parse_arguments(int argc, char *argv[]) {
+  CommandLine cmdline;
+
+  std::vector<std::string> arguments;
+  for (int i = 1; i < argc; i++) {
+    std::string arg{argv[i]};
+    if ((arg == "--help") || (arg == "-h")) {
+      cmdline.show_help = true;
+      return cmdline;
+    } else if (arg == "--show-procedures") {
+      cmdline.show_procedures = ListingMode::HumanReadable;
+    } else if (arg == "-l") {
+      cmdline.show_procedures = ListingMode::PlainLines;
+    } else if (arg == "--json") {
+      cmdline.show_procedures = ListingMode::Json;
+    } else {
+      arguments.push_back(std::move(arg));
+    }
+  }
+
+  if (cmdline.show_procedures != ListingMode::None || cmdline.show_help) {
+    return cmdline;
+  }
+
+  enum class Target {
+    None,
+    Procedure,
+    File,
+  };
+
+  auto target = Target::None;
+
+  // the presence of '--', so we can have files/names started with '-'
+  bool seen_arg_escape = false;
+
+  for (size_t i = 0; i < arguments.size(); /**/) {
+    const std::string &arg = arguments[i];
+
+    if ((arg == "-F") || (arg == "--input-file")) {
+      target = Target::File;
+      seen_arg_escape = false;
+      i += 1;
+    } else if ((arg == "-P") || (arg == "--procedure")) {
+      seen_arg_escape = false;
+      target = Target::Procedure;
+      i += 1;
+    } else if ((arg == "-I") || (arg == "--iterations")) {
+      seen_arg_escape = false;
+      target = Target::None;
+      const std::string &value = arguments.at(i + 1);
+      const long iterations = std::stoi(value);
+      if (iterations <= 0) {
+        throw std::invalid_argument("Iterations must be greater than zero");
+      }
+
+      cmdline.iterations.insert(iterations);
+
+      i += 2;
+    } else if (arg == "--random-utf8") {
+      seen_arg_escape = false;
+      target = Target::None;
+      const std::string &value = arguments.at(i + 1);
+      const long size = std::stoi(value);
+      if (size <= 0) {
+        throw std::invalid_argument("Input size must be greater than zero");
+      }
+      cmdline.random_size.insert(size);
+
+      i += 2;
+    } else {
+      if (arg == "--") {
+        seen_arg_escape = true;
+        i += 1;
+        continue;
+      }
+
+      if (!seen_arg_escape && !arg.empty() && arg[0] == '-') {
+        throw std::invalid_argument("Unknown option '" + arg + "'");
+      }
+
+      switch (target) {
+      case Target::None:
+        throw std::invalid_argument("Unexpected argument '" + arg + "'");
+
+      case Target::Procedure:
+        cmdline.procedures.insert(arg);
+        i += 1;
+        break;
+
+      case Target::File:
+        cmdline.files.insert(arg);
+        i += 1;
+        break;
+      }
+    }
+  } // for
+
+  return cmdline;
+}
+
+void fixup_and_validate(CommandLine &cmdline) {
+  if (cmdline.iterations.empty()) {
+    const bool default_needed =
+        (!cmdline.procedures.empty() || !cmdline.random_size.empty() ||
+         !cmdline.files.empty());
+    if (default_needed)
+      cmdline.iterations.insert(DEFAULT_ITERATIONS);
+  }
+
+  for (const auto &path : cmdline.files) {
+    if (!std::filesystem::exists(path))
+      throw std::runtime_error("File " + path.string() + " does not exist");
+  }
+}
+
+} // namespace
+
+namespace simdutf::benchmarks {
+
+CommandLine CommandLine::parse_arguments(int argc, char *argv[]) {
+  CommandLine cmdline{::parse_arguments(argc, argv)};
+
+  fixup_and_validate(cmdline);
+
+  return cmdline;
+}
+
+bool CommandLine::empty() const {
+  return procedures.empty() && random_size.empty() && files.empty() &&
+         iterations.empty() && (show_procedures == ListingMode::None);
+}
+
+void CommandLine::print_help() { print_help(stdout); }
+
+void CommandLine::print_help(FILE *file) {
+  fputs(R"txt(
+Benchmark utility for simdutf
+
+Usage:
+
+    -h, --help                      show help
+    -F [PATH], --input-file [PATH]  set dataset path (may be used many times)
+    -P [NAME], --procedure [NAME]   choose procedure(s) to test (may be used many times, a substring match suffices)
+    -I --iterations                 number of iterations (default: 3000)
+    --random-utf8 [size]            use random UTF8 data of given size
+    --show-procedures               list all known procedures in a human-readable way
+    -l                              list all known procedures in a machine-friendly format
+
+Examples:
+
+    # test all known UTF8 procedures against 10k random input (in 100 iterations)
+    $ benchmark --random-utf8 10240 -I 100
+
+    # test procedures implemented with the haswell kernel against two custom files
+    $ benchmark -P haswell -F ~/plain_ascii.txt -F ~/chinese_huge.txt
+
+    # test two selected procedures against all files matching a pattern (POSIX)
+    $ benchmark -P convert_utf8_to_utf16+llvm convert_utf8_to_utf16+u8u16 -F *.utf8.txt
+)txt",
+        file);
+}
+
+} // namespace simdutf::benchmarks

package/deps/simdutf/benchmarks/src/cmdline.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdio>
+#include <filesystem>
+#include <string>
+#include <set>
+
+namespace simdutf::benchmarks {
+
+enum class ListingMode {
+  None,
+  HumanReadable,
+  PlainLines,
+  Json,
+};
+
+class CommandLine {
+public:
+  bool show_help = false;
+  ListingMode show_procedures = ListingMode::None;
+  std::set<std::string> procedures;
+  std::set<size_t> random_size;
+  std::set<std::filesystem::path> files;
+  std::set<size_t> iterations;
+
+public:
+  CommandLine() = default;
+  static CommandLine parse_arguments(int argc, char *argv[]);
+
+  bool empty() const;
+  static void print_help(FILE *);
+  static void print_help();
+};
+} // namespace simdutf::benchmarks

package/deps/simdutf/benchmarks/src/event_counter.h

@@ -0,0 +1,162 @@
+#ifndef __EVENT_COUNTER_H
+#define __EVENT_COUNTER_H
+
+#include <cctype>
+#ifndef _MSC_VER
+  #include <dirent.h>
+#endif
+#include <cinttypes>
+
+#include <cstring>
+
+#include <chrono>
+#include <vector>
+
+#include "linux-perf-events.h"
+#ifdef __linux__
+  #include <libgen.h>
+#endif
+
+#if __APPLE__ && __aarch64__
+  #include "apple_arm_events.h"
+#endif
+
+struct event_count {
+  std::chrono::duration<double> elapsed;
+  std::vector<unsigned long long> event_counts;
+  event_count() : elapsed(0), event_counts{0, 0, 0, 0, 0} {}
+  event_count(const std::chrono::duration<double> _elapsed,
+              const std::vector<unsigned long long> _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,
+    INSTRUCTIONS,
+    BRANCH_MISSES,
+  };
+
+  double elapsed_sec() const {
+    return std::chrono::duration<double>(elapsed).count();
+  }
+  double elapsed_ns() const {
+    return std::chrono::duration<double, std::nano>(elapsed).count();
+  }
+  double cycles() const {
+    return static_cast<double>(event_counts[CPU_CYCLES]);
+  }
+  double instructions() const {
+    return static_cast<double>(event_counts[INSTRUCTIONS]);
+  }
+  double branch_misses() const {
+    return static_cast<double>(event_counts[BRANCH_MISSES]);
+  }
+
+  event_count &operator=(const event_count &other) {
+    this->elapsed = other.elapsed;
+    this->event_counts = other.event_counts;
+    return *this;
+  }
+  event_count operator+(const event_count &other) const {
+    return event_count(elapsed + other.elapsed,
+                       {
+                           event_counts[0] + other.event_counts[0],
+                           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],
+                       });
+  }
+  event_count operator/(size_t multiplier) const {
+    return event_count(elapsed / multiplier, {
+                                                 event_counts[0] / multiplier,
+                                                 event_counts[1] / multiplier,
+                                                 event_counts[2] / multiplier,
+                                                 event_counts[3] / multiplier,
+                                                 event_counts[4] / multiplier,
+                                             });
+  }
+  void operator+=(const event_count &other) { *this = *this + other; }
+};
+
+struct event_aggregate {
+  bool has_events = false;
+  int iterations = 0;
+  event_count total{};
+  event_count best{};
+  event_count worst{};
+
+  event_aggregate() = default;
+
+  void operator<<(const event_count &other) {
+    if (iterations == 0 || other.elapsed < best.elapsed) {
+      best = other;
+    }
+    if (iterations == 0 || other.elapsed > worst.elapsed) {
+      worst = other;
+    }
+    iterations++;
+    total += other;
+  }
+  double total_elapsed_ns() const { return total.elapsed_ns(); }
+  double elapsed_sec() const { return total.elapsed_sec() / iterations; }
+  double elapsed_ns() const { return total.elapsed_ns() / iterations; }
+  double cycles() const { return total.cycles() / iterations; }
+  double instructions() const { return total.instructions() / iterations; }
+};
+
+struct event_collector {
+  event_count count{};
+  std::chrono::time_point<std::chrono::steady_clock> start_clock{};
+
+#if defined(__linux__)
+  LinuxEvents<PERF_TYPE_HARDWARE> linux_events;
+  event_collector()
+      : linux_events(std::vector<int>{
+            PERF_COUNT_HW_CPU_CYCLES,
+            PERF_COUNT_HW_INSTRUCTIONS,
+        }) {}
+  bool has_events() { return linux_events.is_working(); }
+#elif __APPLE__ && __aarch64__
+  AppleEvents apple_events;
+  performance_counters diff;
+  event_collector() : diff(0) { apple_events.setup_performance_counters(); }
+  bool has_events() { return apple_events.setup_performance_counters(); }
+#else
+  event_collector() {}
+  bool has_events() { return false; }
+#endif
+
+  inline void start() {
+#if defined(__linux)
+    linux_events.start();
+#elif __APPLE__ && __aarch64__
+    if (has_events()) {
+      diff = apple_events.get_counters();
+    }
+#endif
+    start_clock = std::chrono::steady_clock::now();
+  }
+  inline event_count &end() {
+    const auto end_clock = std::chrono::steady_clock::now();
+#if defined(__linux)
+    linux_events.end(count.event_counts);
+#elif __APPLE__ && __aarch64__
+    if (has_events()) {
+      performance_counters end = apple_events.get_counters();
+      diff = end - diff;
+    }
+    count.event_counts[0] = diff.cycles;
+    count.event_counts[1] = diff.instructions;
+    count.event_counts[2] = diff.missed_branches;
+    count.event_counts[3] = 0;
+    count.event_counts[4] = 0;
+#endif
+    count.elapsed = end_clock - start_clock;
+    return count;
+  }
+};
+
+#endif

package/deps/simdutf/benchmarks/src/linux-perf-events.h

@@ -0,0 +1,104 @@
+#pragma once
+#ifdef __linux__
+
+  #include <asm/unistd.h>       // for __NR_perf_event_open
+  #include <linux/perf_event.h> // for perf event constants
+  #include <sys/ioctl.h>        // for ioctl
+  #include <unistd.h>           // for syscall
+
+  #include <cerrno>  // for errno
+  #include <cstring> // for memset
+  #include <stdexcept>
+
+  #include <iostream>
+  #include <vector>
+
+template <int TYPE = PERF_TYPE_HARDWARE> class LinuxEvents {
+  int fd;
+  bool working;
+  perf_event_attr attribs{};
+  size_t num_events{};
+  std::vector<uint64_t> temp_result_vec{};
+  std::vector<uint64_t> ids{};
+
+public:
+  explicit LinuxEvents(std::vector<int> config_vec) : fd(0), working(true) {
+    memset(&attribs, 0, sizeof(attribs));
+    attribs.type = TYPE;
+    attribs.size = sizeof(attribs);
+    attribs.disabled = 1;
+    attribs.exclude_kernel = 1;
+    attribs.exclude_hv = 1;
+
+    attribs.sample_period = 0;
+    attribs.read_format = PERF_FORMAT_GROUP | PERF_FORMAT_ID;
+    const int pid = 0;  // the current process
+    const int cpu = -1; // all CPUs
+    const unsigned long flags = 0;
+
+    int group = -1; // no group
+    num_events = config_vec.size();
+    ids.resize(config_vec.size());
+    uint32_t i = 0;
+    for (auto config : config_vec) {
+      attribs.config = config;
+      int _fd = static_cast<int>(
+          syscall(__NR_perf_event_open, &attribs, pid, cpu, group, flags));
+      if (_fd == -1) {
+        report_error("perf_event_open");
+      }
+      ioctl(_fd, PERF_EVENT_IOC_ID, &ids[i++]);
+      if (group == -1) {
+        group = _fd;
+        fd = _fd;
+      }
+    }
+
+    temp_result_vec.resize(num_events * 2 + 1);
+  }
+
+  ~LinuxEvents() {
+    if (fd != -1) {
+      close(fd);
+    }
+  }
+
+  inline void start() {
+    if (fd != -1) {
+      if (ioctl(fd, PERF_EVENT_IOC_RESET, PERF_IOC_FLAG_GROUP) == -1) {
+        report_error("ioctl(PERF_EVENT_IOC_RESET)");
+      }
+
+      if (ioctl(fd, PERF_EVENT_IOC_ENABLE, PERF_IOC_FLAG_GROUP) == -1) {
+        report_error("ioctl(PERF_EVENT_IOC_ENABLE)");
+      }
+    }
+  }
+
+  inline void end(std::vector<unsigned long long> &results) {
+    if (fd != -1) {
+      if (ioctl(fd, PERF_EVENT_IOC_DISABLE, PERF_IOC_FLAG_GROUP) == -1) {
+        report_error("ioctl(PERF_EVENT_IOC_DISABLE)");
+      }
+
+      if (read(fd, temp_result_vec.data(), temp_result_vec.size() * 8) == -1) {
+        report_error("read");
+      }
+    }
+    // our actual results are in slots 1,3,5, ... of this structure
+    for (uint32_t i = 1; i < temp_result_vec.size(); i += 2) {
+      results[i / 2] = temp_result_vec[i];
+    }
+    for (uint32_t i = 2; i < temp_result_vec.size(); i += 2) {
+      if (ids[i / 2 - 1] != temp_result_vec[i]) {
+        report_error("event mismatch");
+      }
+    }
+  }
+
+  bool is_working() { return working; }
+
+private:
+  void report_error(const std::string &) { working = false; }
+};
+#endif

package/deps/simdutf/benchmarks/stream.cpp

@@ -0,0 +1,209 @@
+/**
+ * This simple program is meant to simply decode substrings of a given
+ * input file.
+ */
+
+#include <chrono>
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+#include <vector>
+#include <cmath>
+
+#ifdef __has_include
+  #if __has_include(<iconv.h>)
+    #ifndef ICONV_AVAILABLE
+      #define ICONV_AVAILABLE 1
+    #endif
+    #include <iconv.h>
+  #endif //__has_include (<iconv.h>)
+#endif   // defined __has_include
+
+#if ICU_AVAILABLE
+  #include <unicode/uconfig.h>
+  #include <unicode/platform.h>
+  #include <unicode/unistr.h>
+  #include <unicode/ucnv.h>
+#endif
+
+#include "simdutf.h"
+
+uint64_t nano() {
+  return std::chrono::duration_cast<::std::chrono::nanoseconds>(
+             std::chrono::steady_clock::now().time_since_epoch())
+      .count();
+}
+
+template <typename PROCEDURE>
+double bench(PROCEDURE f, uint64_t threshold = 200'000'000) {
+  uint64_t start = nano();
+  uint64_t finish = start;
+  size_t times{0};
+  for (; finish - start < threshold; times++) {
+    size_t output_size = f();
+    if (output_size == 0) {
+      throw std::runtime_error("bad input?");
+    }
+    finish = nano();
+  }
+  return double(finish - start) / times;
+}
+
+size_t trim_partial_utf8(const uint8_t *buf, size_t len) {
+  if (len < 3) {
+    switch (len) {
+    case 2:
+      if (buf[len - 1] >= 0b11000000) {
+        return len - 1;
+      } // 2-, 3- and 4-byte characters with only 1 byte left
+      if (buf[len - 2] >= 0b11100000) {
+        return len - 2;
+      } // 3- and 4-byte characters with only 2 bytes left
+      return len;
+    case 1:
+      if (buf[len - 1] >= 0b11000000) {
+        return len - 1;
+      } // 2-, 3- and 4-byte characters with only 1 byte left
+      return len;
+    case 0:
+      return len;
+    }
+  }
+  if (buf[len - 1] >= 0b11000000) {
+    return len - 1;
+  } // 2-, 3- and 4-byte characters with only 1 byte left
+  if (buf[len - 2] >= 0b11100000) {
+    return len - 2;
+  } // 3- and 4-byte characters with only 1 byte left
+  if (buf[len - 3] >= 0b11110000) {
+    return len - 3;
+  } // 4-byte characters with only 3 bytes left
+  return len;
+}
+
+size_t trim_partial_utf16(const uint16_t *buf, size_t len) {
+  if (len == 0) {
+    return 0;
+  }
+  if ((buf[len - 1] >= 0xD800) && (buf[len - 1] <= 0xDBFF)) {
+    return len - 1;
+  }
+  return len;
+}
+
+void run_from_utf8(const std::vector<char> &input_data,
+                   size_t approx_output_datapoints = 128) {
+  std::vector<char16_t> buffer(
+      simdutf::utf16_length_from_utf8(input_data.data(), input_data.size()));
+  size_t min_len = 64;
+  if (input_data.size() < min_len) {
+    return;
+  }
+#if ICONV_AVAILABLE
+  iconv_t cv = iconv_open("UTF-16", "ISO-8859-1");
+  if (cv == (iconv_t)(-1)) {
+    fprintf(stderr,
+            "[iconv] cannot initialize ISO-8859-1 to UTF-16 converter\n");
+  } else {
+    std::cout << "# [iconv] initialized ISO-8859-1 to UTF-16 converter\n";
+  }
+  std::cout << "n,\tsimdutf-speed\ticonv-speed\n";
+#else
+  std::cout << "n,\tsimdutf-speed\n";
+#endif
+  size_t offset = size_t(
+      round(double(input_data.size() - min_len) / approx_output_datapoints));
+  for (size_t len = min_len; len <= input_data.size();
+       len += (len < offset ? offset / 50 + 1 : offset)) {
+    size_t effective_length = trim_partial_utf8(
+        reinterpret_cast<const uint8_t *>(input_data.data()), len);
+    size_t utf8count = simdutf::count_utf8(input_data.data(), effective_length);
+    std::cout << utf8count << ",\t";
+    auto size_procedure = [effective_length, &input_data, &buffer]() -> size_t {
+      return simdutf::convert_utf8_to_utf16le(input_data.data(),
+                                              effective_length, buffer.data());
+    };
+
+#if ICONV_AVAILABLE
+    auto iconv_size_procedure = [&cv, effective_length, &input_data,
+                                 &buffer]() -> size_t {
+      size_t inbytes = effective_length;
+      size_t outbytes = buffer.size();
+  #ifdef WINICONV_CONST
+      WINICONV_CONST char *inptr =
+          reinterpret_cast<WINICONV_CONST char *>(input_data.data());
+  #else
+      char *inptr = const_cast<char *>(input_data.data());
+  #endif
+      char *outptr = reinterpret_cast<char *>(buffer.data());
+      size_t result = iconv(cv, &inptr, &inbytes, &outptr, &outbytes);
+      (void)result;
+      return outbytes;
+    };
+    std::cout << utf8count / bench(size_procedure) << "\t"
+              << utf8count / bench(iconv_size_procedure) << "\n";
+#else
+    std::cout << utf8count / bench(size_procedure) << "\n";
+#endif
+  }
+}
+
+void run_from_utf16(const std::vector<char> &input_data,
+                    size_t approx_output_datapoints = 128) {
+  std::vector<char> buffer(simdutf::utf8_length_from_utf16le(
+      reinterpret_cast<const char16_t *>(input_data.data()),
+      input_data.size() / 2));
+  size_t min_len = 64;
+  if (input_data.size() < min_len) {
+    return;
+  }
+  std::cout << "n,\tsimdutf-speed\n";
+  size_t offset = size_t(
+      round(double(input_data.size() - min_len) / approx_output_datapoints));
+  for (size_t len = min_len; len <= input_data.size();
+       len += (len < offset ? offset / 50 + 1 : offset)) {
+    size_t effective_length = trim_partial_utf16(
+        reinterpret_cast<const uint16_t *>(input_data.data()), len / 2);
+    size_t utf16count = simdutf::count_utf16le(
+        reinterpret_cast<const char16_t *>(input_data.data()),
+        effective_length);
+    std::cout << utf16count << ",\t";
+    auto size_procedure = [effective_length, &input_data, &buffer]() -> size_t {
+      return simdutf::convert_utf16le_to_utf8(
+          reinterpret_cast<const char16_t *>(input_data.data()),
+          effective_length, buffer.data());
+    };
+    std::cout << utf16count / bench(size_procedure) << "\n";
+  }
+}
+
+int main(int argc, char **argv) {
+  printf("# current system detected as %s.\n",
+         simdutf::get_active_implementation()->name().c_str());
+  if (argc < 2) {
+    std::cerr << "Please provide a file argument." << std::endl;
+    std::cerr << "The file should contain either UTF-8 or UTF-16 text."
+              << std::endl;
+    std::cerr << "We then process prefixes of increasing length." << std::endl;
+    return EXIT_FAILURE;
+  }
+  const char *filename = argv[1];
+  printf("# loading file %s\n", filename);
+  std::filesystem::path path(filename);
+  std::ifstream file;
+  file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
+  file.open(path);
+  std::vector<char> input_data;
+  input_data.assign(std::istreambuf_iterator<char>(file),
+                    std::istreambuf_iterator<char>());
+  auto detected_encoding =
+      simdutf::autodetect_encoding(input_data.data(), input_data.size());
+  printf("# input detected as %s.\n",
+         simdutf::to_string(detected_encoding).c_str());
+  if (detected_encoding == simdutf::encoding_type::UTF16_LE) {
+    run_from_utf16(input_data);
+  } else if (detected_encoding == simdutf::encoding_type::UTF8) {
+    run_from_utf8(input_data);
+  }
+  return EXIT_SUCCESS;
+}