react-native-quick-crypto 1.0.18 → 1.1.0

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

@@ -0,0 +1,317 @@
+#pragma once
+#include "benchmark_base.h"
+#include "cmdline.h"
+#include "simdutf.h"
+#include <variant>
+#include <cstddef>
+
+/**
+ * ICU is a standard library that is often already present on the system.
+ */
+#if defined __has_include
+  #if !defined(ICU_AVAILABLE) && __has_include(<unicode/unistr.h>)
+    #define ICU_AVAILABLE 1
+  // U_ICU_VERSION is relevant here.
+  #endif //__has_include (<unicode/unistr.h>)
+
+  #if !defined(ICONV_AVAILABLE) && __has_include(<iconv.h>)
+    #define ICONV_AVAILABLE 1
+  #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
+
+#if ICONV_AVAILABLE
+  #include <iconv.h>
+#endif
+/**
+ * inoue2008 is:
+ * Hiroshi Inoue and Hideaki Komatsu and Toshio Nakatani,
+ * Accelerating UTF-8 Decoding Using SIMD Instructions (in Japanese),
+ * Information Processing Society of Japan Transactions on Programming 1 (2),
+ * 2008.
+ */
+#include "benchmarks/competition/inoue2008/inoue_utf8_to_utf16.h"
+
+/**
+ * Nemanja Trifunovic, UTF8-CPP: UTF-8 with C++ in a Portable Way
+ * https://github.com/nemtrif/utfcpp/releases/tag/v3.2.2
+ */
+#include "benchmarks/competition/utfcpp/source/utf8.h"
+
+namespace simdutf::benchmarks {
+
+class Benchmark : public BenchmarkBase {
+public:
+  using BenchmarkBase::run;
+
+  Benchmark(std::vector<input::Testcase> &&testcases);
+
+  static Benchmark create(const CommandLine &cmdline);
+  virtual const std::set<std::string> all_procedures() const override;
+  virtual std::set<simdutf::encoding_type>
+  expected_encodings(const std::string &procedure) override;
+
+  void list_procedures(ListingMode) const;
+
+protected:
+  virtual void run(const std::string &procedure_name,
+                   size_t iterations) override;
+
+private:
+  using simdutf_fn = void (Benchmark::*)(const simdutf::implementation &,
+                                         size_t);
+  using thirdparty_fn = void (Benchmark::*)(size_t);
+
+  std::map<std::string, std::pair<std::variant<simdutf_fn, thirdparty_fn>,
+                                  std::set<simdutf::encoding_type>>>
+      benchmarks;
+
+  template <typename Fn>
+  void register_function(std::string name, Fn function,
+                         std::set<simdutf::encoding_type> set);
+
+  template <typename Fn>
+  void register_function(std::string name, Fn function,
+                         simdutf::encoding_type enc1);
+  template <typename Fn>
+  void register_function(std::string name, Fn function,
+                         simdutf::encoding_type enc1,
+                         simdutf::encoding_type enc2);
+  template <typename Fn>
+  void
+  register_function(std::string name, Fn function, simdutf::encoding_type enc1,
+                    simdutf::encoding_type enc2, simdutf::encoding_type enc3);
+
+private:
+  void run_naive_validate_ascii(const simdutf::implementation &implementation,
+                                size_t iterations);
+  void run_validate_ascii(const simdutf::implementation &implementation,
+                          size_t iterations);
+  void
+  run_validate_ascii_with_errors(const simdutf::implementation &implementation,
+                                 size_t iterations);
+  void run_validate_utf8(const simdutf::implementation &implementation,
+                         size_t iterations);
+  void
+  run_validate_utf8_with_errors(const simdutf::implementation &implementation,
+                                size_t iterations);
+  void run_validate_utf16le(const simdutf::implementation &implementation,
+                            size_t iterations);
+  void run_validate_utf16le_with_errors(
+      const simdutf::implementation &implementation, size_t iterations);
+  void run_validate_utf32(const simdutf::implementation &implementation,
+                          size_t iterations);
+  void run_to_well_formed_utf16le(const simdutf::implementation &implementation,
+                                  size_t iterations);
+  void
+  run_validate_utf32_with_errors(const simdutf::implementation &implementation,
+                                 size_t iterations);
+  void run_count_utf8(const simdutf::implementation &implementation,
+                      size_t iterations);
+  void run_count_utf16le(const simdutf::implementation &implementation,
+                         size_t iterations);
+  void
+  run_utf8_length_from_latin1(const simdutf::implementation &implementation,
+                              size_t iterations);
+  void
+  run_utf8_length_from_utf16le(const simdutf::implementation &implementation,
+                               size_t iterations);
+  void
+  run_utf8_length_from_utf16be(const simdutf::implementation &implementation,
+                               size_t iterations);
+  void run_utf8_length_from_utf16le_with_replacement(
+      const simdutf::implementation &implementation, size_t iterations);
+  void run_utf8_length_from_utf16be_with_replacement(
+      const simdutf::implementation &implementation, size_t iterations);
+  void run_utf8_length_from_utf32(const simdutf::implementation &implementation,
+                                  size_t iterations);
+  void run_utf16_length_from_utf8(const simdutf::implementation &implementation,
+                                  size_t iterations);
+  void run_convert_latin1_to_utf8(const simdutf::implementation &implementation,
+                                  size_t iterations);
+  void
+  run_convert_latin1_to_utf16le(const simdutf::implementation &implementation,
+                                size_t iterations);
+  void
+  run_convert_latin1_to_utf32(const simdutf::implementation &implementation,
+                              size_t iterations);
+  void run_convert_utf8_to_latin1(const simdutf::implementation &implementation,
+                                  size_t iterations);
+  void run_convert_utf8_to_latin1_with_errors(
+      const simdutf::implementation &implementation, size_t iterations);
+  void
+  run_convert_utf8_to_utf16le(const simdutf::implementation &implementation,
+                              size_t iterations);
+  void run_convert_utf8_to_utf16le_with_errors(
+      const simdutf::implementation &implementation, size_t iterations);
+  void run_convert_utf8_to_utf32(const simdutf::implementation &implementation,
+                                 size_t iterations);
+  void run_convert_utf8_to_utf32_with_errors(
+      const simdutf::implementation &implementation, size_t iterations);
+  void run_convert_utf8_to_utf16le_with_dynamic_allocation(
+      const simdutf::implementation &implementation, size_t iterations);
+  void run_convert_utf8_to_utf32_with_dynamic_allocation(
+      const simdutf::implementation &implementation, size_t iterations);
+  void run_convert_valid_utf8_to_latin1(
+      const simdutf::implementation &implementation, size_t iterations);
+  void run_convert_valid_utf8_to_utf16le(
+      const simdutf::implementation &implementation, size_t iterations);
+  void
+  run_convert_valid_utf8_to_utf32(const simdutf::implementation &implementation,
+                                  size_t iterations);
+  void
+  run_convert_utf16le_to_latin1(const simdutf::implementation &implementation,
+                                size_t iterations);
+  void run_convert_utf16le_to_latin1_with_errors(
+      const simdutf::implementation &implementation, size_t iterations);
+  void
+  run_convert_utf16le_to_utf8(const simdutf::implementation &implementation,
+                              size_t iterations);
+  void
+  run_convert_utf16_to_utf8_safe(const simdutf::implementation &implementation,
+                                 size_t iterations);
+  void run_convert_utf16le_to_utf8_with_errors(
+      const simdutf::implementation &implementation, size_t iterations);
+  void
+  run_convert_utf16le_to_utf32(const simdutf::implementation &implementation,
+                               size_t iterations);
+  void run_convert_utf16le_to_utf32_with_errors(
+      const simdutf::implementation &implementation, size_t iterations);
+  void run_convert_utf16le_to_utf8_with_dynamic_allocation(
+      const simdutf::implementation &implementation, size_t iterations);
+  void run_convert_utf16le_to_utf32_with_dynamic_allocation(
+      const simdutf::implementation &implementation, size_t iterations);
+  void run_convert_valid_utf16le_to_latin1(
+      const simdutf::implementation &implementation, size_t iterations);
+  void run_convert_valid_utf16le_to_utf8(
+      const simdutf::implementation &implementation, size_t iterations);
+  void
+  run_convert_utf32_to_latin1(const simdutf::implementation &implementation,
+                              size_t iterations);
+  void run_convert_utf32_to_latin1_with_errors(
+      const simdutf::implementation &implementation, size_t iterations);
+  void run_convert_utf32_to_utf8(const simdutf::implementation &implementation,
+                                 size_t iterations);
+  void run_convert_utf32_to_utf8_with_errors(
+      const simdutf::implementation &implementation, size_t iterations);
+  void run_convert_valid_utf32_to_latin1(
+      const simdutf::implementation &implementation, size_t iterations);
+  void
+  run_convert_valid_utf32_to_utf8(const simdutf::implementation &implementation,
+                                  size_t iterations);
+
+  template <endianness byte_order>
+  void run_convert_utf32_to_utf16(const simdutf::implementation &implementation,
+                                  size_t iterations);
+  template <endianness byte_order>
+  void run_convert_utf32_to_utf16_with_errors(
+      const simdutf::implementation &implementation, size_t iterations);
+
+  template <endianness byte_order>
+  void run_convert_valid_utf32_to_utf16(
+      const simdutf::implementation &implementation, size_t iterations);
+
+  void run_convert_valid_utf16le_to_utf32(
+      const simdutf::implementation &implementation, size_t iterations);
+  void run_detect_encodings(const simdutf::implementation &implementation,
+                            size_t iterations);
+  void run_utf8_length_from_latin1_node(size_t iterations);
+#if ICU_AVAILABLE
+  void run_convert_latin1_to_utf8_icu(size_t iterations);
+  void run_convert_latin1_to_utf16_icu(size_t iterations);
+  void run_convert_latin1_to_utf32_icu(size_t iterations);
+  void run_convert_utf8_to_latin1_icu(size_t iterations);
+  void run_convert_utf8_to_utf16_icu(size_t iterations);
+  void run_convert_utf16_to_utf8_icu(size_t iterations);
+  void run_convert_utf16_to_latin1_icu(size_t iterations);
+  void run_convert_utf32_to_latin1_icu(size_t iterations);
+#endif
+#if ICONV_AVAILABLE
+  void run_convert_latin1_to_utf8_iconv(size_t iterations);
+  void run_convert_latin1_to_utf16_iconv(size_t iterations);
+  void run_convert_latin1_to_utf32_iconv(size_t iterations);
+  void run_convert_utf8_to_latin1_iconv(size_t iterations);
+  void run_convert_utf8_to_utf16_iconv(size_t iterations);
+  void run_convert_utf16_to_utf8_iconv(size_t iterations);
+  void run_convert_utf16_to_latin1_iconv(size_t iterations);
+  void run_convert_utf32_to_latin1_iconv(size_t iterations);
+#endif
+#ifdef INOUE2008
+  /**
+   * Hiroshi Inoue and Hideaki Komatsu and Toshio Nakatani,
+   * Accelerating UTF-8 Decoding Using SIMD Instructions (in Japanese),
+   * Information Processing Society of Japan Transactions on Programming 1 (2),
+   * 2008.
+   */
+  void run_convert_valid_utf8_to_utf16_inoue2008(size_t iterations);
+#endif
+#ifdef __x86_64__
+  /**
+   * utf8lut: Vectorized UTF-8 converter.
+   * by stgatilov (2019)
+   *  https://dirtyhandscoding.github.io/posts/utf8lut-vectorized-utf-8-converter-introduction.html
+   */
+  void run_convert_utf16_to_utf8_utf8lut(size_t iterations);
+  void run_convert_valid_utf16_to_utf8_utf8lut(size_t iterations);
+
+  void run_convert_utf8_to_utf16_utf8lut(size_t iterations);
+  void run_convert_utf8_to_utf32_utf8lut(size_t iterations);
+  void run_convert_valid_utf8_to_utf16_utf8lut(size_t iterations);
+  void run_convert_valid_utf8_to_utf32_utf8lut(size_t iterations);
+
+  void run_convert_utf32_to_utf8_utf8lut(size_t iterations);
+  void run_convert_valid_utf32_to_utf8_utf8lut(size_t iterations);
+
+  /**
+   * Bob Steagall, CppCon2018
+   * https://github.com/BobSteagall/CppCon2018/
+   *
+   * Fast Conversion From UTF-8 with C++, DFAs, and SSE Intrinsics
+   * https://www.youtube.com/watch?v=5FQ87-Ecb-A
+   */
+  void run_convert_utf8_to_utf16_cppcon2018(size_t iterations);
+  void run_convert_utf8_to_utf32_cppcon2018(size_t iterations);
+  /**
+   * benchmarks/competition/u8u16 contains an open source version of u8u16,
+   * referenced in Cameron, Robert D, A case study in SIMD text processing with
+   * parallel bit streams: UTF-8 to UTF-16 transcoding, Proceedings of the 13th
+   * ACM SIGPLAN Symposium on Principles and practice of parallel programming,
+   * 91--98.
+   */
+  void run_convert_utf8_to_utf16_u8u16(size_t iterations);
+  /**
+   * Olivier Goffart, UTF-8 processing using SIMD (SSE4), 2012.
+   * https://woboq.com/blog/utf-8-processing-using-simd.html
+   */
+  void run_convert_utf8_to_utf16_utf8sse4(size_t iterations);
+#endif
+  void run_convert_utf8_to_utf16_hoehrmann(size_t iterations);
+  void run_convert_utf8_to_utf32_hoehrmann(size_t iterations);
+  /**
+   * LLVM relies on code from the Unicode Consortium
+   * https://en.wikipedia.org/wiki/Unicode_Consortium
+   */
+  void run_convert_utf8_to_utf16_llvm(size_t iterations);
+  void run_convert_utf8_to_utf32_llvm(size_t iterations);
+  void run_convert_utf16_to_utf8_llvm(size_t iterations);
+  void run_convert_utf32_to_utf8_llvm(size_t iterations);
+  void run_convert_utf32_to_utf16_llvm(size_t iterations);
+  void run_convert_utf16_to_utf32_llvm(size_t iterations);
+  /**
+   * Nemanja Trifunovic, UTF8-CPP: UTF-8 with C++ in a Portable Way
+   * https://github.com/nemtrif/utfcpp/releases/tag/v3.2.2
+   */
+  void run_convert_utf8_to_utf16_utfcpp(size_t iterations);
+  void run_convert_utf16_to_utf8_utfcpp(size_t iterations);
+  void run_convert_utf8_to_utf32_utfcpp(size_t iterations);
+  void run_convert_utf32_to_utf8_utfcpp(size_t iterations);
+};
+
+} // namespace simdutf::benchmarks

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

@@ -0,0 +1,144 @@
+#include "benchmark_base.h"
+#include "tests/helpers/random_utf8.h"
+#include "simdutf.h"
+#include <fstream>
+#include <iostream>
+
+namespace simdutf::benchmarks {
+
+BenchmarkBase::BenchmarkBase(std::vector<input::Testcase> &&testcases)
+    : testcases{std::move(testcases)} {}
+
+bool BenchmarkBase::run() {
+  printf("testcases: %zu\n", size_t(testcases.size()));
+  for (const auto &testcase : testcases) {
+    run(testcase);
+  }
+
+  return true;
+}
+
+void BenchmarkBase::run(const input::Testcase &testcase) {
+  prepare_input(testcase);
+  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());
+  printf("===========================\n");
+
+  const auto &known_procedures = all_procedures();
+
+  if (testcase.tested_procedures.empty()) {
+    for (const std::string &procedure : known_procedures) {
+      // We will first identify the input.
+      auto expected_input_encoding = expected_encodings(procedure);
+      const bool is_in = expected_input_encoding.find(detected_encoding) !=
+                         expected_input_encoding.end();
+      if (is_in) {
+        run(procedure, testcase);
+      }
+    }
+  } else {
+    std::set<std::string> to_be_tested;
+    for (const auto &procedure : testcase.tested_procedures) {
+      for (const auto &candidate : known_procedures) {
+        if (candidate.find(procedure) != std::string::npos) {
+          to_be_tested.insert(candidate);
+        }
+      }
+    }
+
+    for (const auto &procedure : to_be_tested) {
+      run(procedure, testcase);
+    }
+  }
+}
+
+void BenchmarkBase::run(const std::string &procedure_name,
+                        const input::Testcase &testcase) {
+  printf("%s, input size: %zu, iterations: %zu", procedure_name.c_str(),
+         size_t(input_data.size()), size_t(testcase.iterations));
+
+  if (std::holds_alternative<input::File>(testcase.input)) {
+    const input::File &file{std::get<input::File>(testcase.input)};
+    // You'd think that the following would work, but no, not always:
+    // printf(", dataset: %s\n", reinterpret_cast<const
+    // char*>(file.path.c_str()));
+    std::string path_string{file.path.string()};
+    printf(", dataset: %s\n",
+           reinterpret_cast<const char *>(path_string.c_str()));
+
+  } else
+    putchar('\n');
+
+  run(procedure_name, testcase.iterations);
+}
+
+void BenchmarkBase::prepare_input(const input::Testcase &testcase) {
+  if (std::holds_alternative<input::File>(testcase.input)) {
+    const input::File &file{std::get<input::File>(testcase.input)};
+    load_file(file.path);
+  } else {
+    uint32_t seed{1234};
+    const input::random_utf8 &random{
+        std::get<input::random_utf8>(testcase.input)};
+
+    simdutf::tests::helpers::random_utf8 gen_1_2_3_4(
+        seed, random.utf_1byte_prob, random.utf_2bytes_prob,
+        random.utf_3bytes_prob, random.utf_4bytes_prob);
+
+    input_data = gen_1_2_3_4.generate(random.size);
+  }
+}
+
+void BenchmarkBase::load_file(const std::filesystem::path &path) {
+  std::ifstream file;
+  file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
+  file.open(path);
+
+  input_data.assign(std::istreambuf_iterator<char>(file),
+                    std::istreambuf_iterator<char>());
+}
+void BenchmarkBase::print_summary(const event_aggregate &all, size_t data_size,
+                                  size_t character_count) const {
+  print_summary(all, double(data_size), double(character_count));
+}
+
+void BenchmarkBase::print_summary(const event_aggregate &all, double data_size,
+                                  double character_count) const {
+  const double best_time = all.best.elapsed_ns();
+  const double avg_time = all.total.elapsed_ns() / all.iterations;
+  const double gbs = data_size / best_time;
+  const double gcs = character_count / best_time;
+  const double byte_per_char = data_size / character_count;
+  const double error_margin = (avg_time / best_time - 1) * 100;
+
+  if (all.has_events) {
+    const double _1GHz = 1000000000.0;
+    const double freq = (all.best.cycles() / all.best.elapsed_sec()) / _1GHz;
+    const double insperbyte = all.best.instructions() / data_size;
+    const double cycleperbyte = all.best.cycles() / data_size;
+
+    const double inspercycle = all.best.instructions() / all.best.cycles();
+
+    printf("%8.3f ins/byte, %8.3f cycle/byte, %8.3f GB/s (%.1f %%),  %8.3f "
+           "GHz, %8.3f ins/cycle \n",
+           insperbyte, cycleperbyte, gbs, error_margin, freq, inspercycle);
+    const double insperchar = all.best.instructions() / character_count;
+    const double cycleperchar = all.best.cycles() / character_count;
+
+    printf("%8.3f ins/char, %8.3f cycle/char, %8.3f Gc/s (%.1f %%) %8.2f "
+           "byte/char %8.1f ns\n",
+           insperchar, cycleperchar, gcs, error_margin, byte_per_char,
+           best_time);
+
+  } else {
+    printf("%8.3f GB/s (%.1f %%) %8.3f Gc/s %8.2f byte/char %8.1f ns\n", gbs,
+           error_margin, gcs, byte_per_char, best_time);
+  }
+  if (error_margin > 10) {
+    printf("WARNING: Measurements are noisy, try increasing iteration count "
+           "(-I).\n");
+  }
+}
+} // namespace simdutf::benchmarks

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

@@ -0,0 +1,98 @@
+#pragma once
+
+#include <set>
+#include <vector>
+#include <map>
+#include <filesystem>
+#include <variant>
+#include <random>
+#include "event_counter.h"
+#include "simdutf.h"
+namespace simdutf::benchmarks {
+
+namespace input {
+struct File {
+  std::filesystem::path path;
+};
+
+struct random_utf8 {
+  size_t size;
+  int utf_1byte_prob = 1;
+  int utf_2bytes_prob = 1;
+  int utf_3bytes_prob = 1;
+  int utf_4bytes_prob = 1;
+};
+
+struct Testcase {
+  std::set<std::string> tested_procedures;
+  size_t iterations;
+  std::variant<File, random_utf8> input;
+};
+} // namespace input
+
+class BenchmarkBase {
+protected:
+  std::vector<uint8_t> input_data;
+  std::vector<uint8_t> output_data;
+
+  std::vector<input::Testcase> testcases;
+
+  uint32_t seed{1234};
+
+public:
+  BenchmarkBase(std::vector<input::Testcase> &&testcases);
+  bool run();
+  virtual const std::set<std::string> all_procedures() const = 0;
+  virtual std::set<simdutf::encoding_type>
+  expected_encodings(const std::string &procedure) = 0;
+
+protected:
+  virtual void run(const std::string &procedure_name, size_t iterations) = 0;
+
+  template <typename PROCEDURE>
+  event_aggregate count_events(PROCEDURE, size_t iterations);
+  void print_summary(const event_aggregate &all, double data_size,
+                     double character_count) const;
+  void print_summary(const event_aggregate &all, size_t data_size,
+                     size_t character_count) const;
+
+  void run(const input::Testcase &testcase);
+  void run(const std::string &procedure_name, const input::Testcase &testcase);
+  void prepare_input(const input::Testcase &benchmark);
+  void load_file(const std::filesystem::path &path);
+};
+
+template <typename PROCEDURE>
+event_aggregate BenchmarkBase::count_events(PROCEDURE procedure,
+                                            size_t iterations) {
+  event_collector collector;
+  event_aggregate all{};
+  // Some inputs are just too small to measure accurately, so we need to scale
+  // them up.
+  size_t multiplier = 1;
+  while (true) {
+    event_aggregate test{};
+    collector.start();
+    for (size_t i = 0; i < multiplier; i++) {
+      procedure();
+    }
+    event_count allocate_count = collector.end();
+    test << allocate_count;
+    if (test.best.elapsed_ns() < 4000) {
+      multiplier *= 2;
+    } else {
+      break;
+    }
+  }
+  for (size_t i = 0; i < iterations; i++) {
+    collector.start();
+    for (size_t i = 0; i < multiplier; i++) {
+      procedure();
+    }
+    event_count allocate_count = collector.end();
+    all << allocate_count / multiplier;
+  }
+  all.has_events = collector.has_events();
+  return all;
+}
+} // namespace simdutf::benchmarks