react-native-quick-crypto 1.1.0 → 1.1.1

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

@@ -1,176 +0,0 @@
-#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

@@ -1,35 +0,0 @@
-#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

@@ -1,162 +0,0 @@
-#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

@@ -1,104 +0,0 @@
-#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

@@ -1,209 +0,0 @@
-/**
- * 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;
-}