react-native-quick-crypto 1.1.0 → 1.1.1

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

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

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

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