react-native-quick-crypto 1.0.18 → 1.1.0

package/deps/simdutf/scripts/benchmark_print.py

@@ -0,0 +1,324 @@
+#!/usr/bin/env python3
+
+import sys
+from pathlib import Path
+from table import Table
+
+
+class Input:
+    def __init__(self):
+        self.procedure = None
+        self.input_size = None
+        self.iterations = None
+        self.dataset = None
+
+    @property
+    def dataset_name(self):
+        if self.dataset:
+            return self.dataset.stem
+        else:
+            return 'none'
+
+    def __str__(self):
+        return '<Input: %s, size: %d, iterations: %s, dataset: %s>' % \
+                (self.procedure, self.input_size, self.iterations, self.dataset)
+
+    __repr__ = __str__
+
+
+class Result:
+    def __init__(self):
+        self.instruction_per_byte = None
+        self.instruction_per_char = None
+        self.instruction_per_cycle = None
+        self.cycle_per_byte = None
+        self.cycle_per_char = None
+        self.bytes_per_char = None
+        self.speed_gigabytes = None
+        self.speed_gigachars = None
+        self.freq = None
+        self.time = None
+
+    def update_from_dict(self, D):
+        while D:
+            unit, value = D.popitem()
+            field = unit2field[unit]
+            if field is not None:
+                setattr(self, field, value)
+
+
+unit2field = {
+    'ins/byte'      : 'instruction_per_byte',
+    'ins/char'      : 'instruction_per_char',
+    'ins/cycle'     : 'instruction_per_cycle',
+    'cycle/byte'    : 'cycle_per_byte',
+    'cycle/char'    : 'cycle_per_char',
+    'byte/char'     : 'byte_per_char',
+    'GHz'           : 'freq',
+    'GB/s'          : 'speed_gigabytes',
+    'Gc/s'          : 'speed_gigachars',
+    'ns'            : 'time',
+    '%'             : None,
+}
+
+
+def parse(file):
+    result = []
+    for line in file:
+        for item in parse_line(line):
+            if isinstance(item, Input):
+                result.append([item, None])
+            else:
+                assert isinstance(item, dict)
+                if result[-1][1] is None:
+                    result[-1][1] = Result()
+
+                result[-1][1].update_from_dict(item)
+
+    return [(input, result) for (input, result) in result if result is not None]
+
+
+def parse_line(line):
+    if 'input size' in line:
+        yield parse_input(normalize_line(line))
+    elif 'GB/s' in line or 'ins/byte' in line or 'ins/char' in line:
+        yield parse_results(normalize_line(line))
+
+
+def normalize_line(line):
+    line = line.replace(',', ' ')
+    line = line.replace(':', ' ')
+    line = line.replace('(', ' ')
+    line = line.replace(')', ' ')
+
+    return line.split()
+
+
+def parse_input(fields):
+    input = Input()
+    input.procedure = fields.pop(0)
+
+    assert fields.pop(0) == 'input'
+    assert fields.pop(0) == 'size'
+    input.input_size = int(fields.pop(0))
+
+    assert fields.pop(0) == 'iterations'
+    input.iterations = int(fields.pop(0))
+
+    try:
+        assert fields.pop(0) == 'dataset'
+        input.dataset = Path(fields.pop(0))
+    except IndexError:
+        pass
+
+    return input
+
+
+def try_float(s):
+    try:
+        return float(s)
+    except ValueError:
+        return
+
+
+def parse_results(fields):
+    """Consumes pairs "number unit" from the list"""
+    D = {}
+
+    while fields:
+        value = try_float(fields.pop(0))
+        if value is not None and fields:
+            D[fields.pop(0)] = value
+
+    return D
+
+
+def speed_comparison(data):
+    procedures = set()
+    datasets = set()
+    results = {}
+
+    for input, result in data:
+        procedures.add(input.procedure)
+        datasets.add(input.dataset_name)
+        results[(input.procedure, input.dataset_name)] = result
+
+    datasets = list(sorted(datasets))
+    procedures = list(sorted(procedures))
+
+    def by_procedure():
+        table = Table()
+        table.set_header(['procedure'] + datasets)
+
+        for procedure in procedures:
+            row = []
+            row.append(procedure)
+            for dataset in datasets:
+                try:
+                    result = results[(procedure, dataset)]
+                    row.append('%0.3f GB/s' % (result.speed_gbs))
+                except KeyError:
+                    row.append('--')
+
+            table.add_row(row)
+
+        return table
+
+    def by_dataset():
+        table = Table()
+        table.set_header(['dataset'] + procedures)
+
+        for dataset in datasets:
+            row = []
+            row.append(dataset)
+            for procedure in procedures:
+                try:
+                    result = results[(procedure, dataset)]
+                    row.append('%0.3f GB/s' % (result.speed_gigabytes))
+                except KeyError:
+                    row.append('--')
+
+            table.add_row(row)
+
+        return table
+
+    if len(procedures) >= len(datasets):
+        return by_procedure()
+    else:
+        return by_dataset()
+
+
+def compare(old, new):
+    collate = {}
+    for input, result in old:
+        key = str(input)
+        collate[key] = [input, result, None]
+
+    for input, result in new:
+        key = str(input)
+        if key not in collate:
+            collate[key] = [input, None, result]
+        else:
+            collate[key][-1] = result
+
+    grouped = {}
+    for _, (input, old, new) in collate.items():
+        if input.procedure not in grouped:
+            grouped[input.procedure] = []
+
+        grouped[input.procedure].append((input, old, new))
+
+    NA = '--'
+    table = Table()
+    table.set_header(["dataset", "size [B]", "iterations", "old GB/s", "new GB/s", "speedup"])
+    for procedure, values in grouped.items():
+        table.add_row([(procedure, 6)])
+        for input, old, new in values:
+            old_speed = old.speed_gigabytes
+            new_speed = new.speed_gigabytes
+            if old_speed is None or new_speed is None:
+                speedup = NA
+            else:
+                speedup = '%0.2fx' % (new_speed / old_speed)
+
+            if old_speed is None:
+                old_speed = NA
+            else:
+                old_speed = '%0.2f' % old_speed
+
+            if new_speed is None:
+                new_speed = NA
+            else:
+                new_speed = '%0.2f' % new_speed
+
+            table.add_row([
+                input.dataset.stem,
+                '%s' % input.input_size,
+                '%s' % input.iterations,
+                old_speed,
+                new_speed,
+                speedup,
+            ])
+
+    return table
+
+
+HELP = """Format output of the benchmark utility
+
+When running a benchmark redirect its output to file (with > or `tee`), like:
+
+$ cd build/benchmarks
+$ ./benchmark [...] > results.txt
+$ ./benchmark [...] | tee results.txt
+
+To summarize results, use:
+
+$ ./benchmark_print.py results.txt
+|     dataset      | utf8_length_from_utf32+fallback | utf8_length_from_utf32+haswell | utf8_length_from_utf32+westmere |
+| ---------------- | ------------------------------- | ------------------------------ | ------------------------------- |
+| arabic.utf32     | 3.190 GB/s                      | 15.638 GB/s                    | 7.879 GB/s                      |
+| chinese.utf32    | 3.179 GB/s                      | 15.349 GB/s                    | 7.644 GB/s                      |
+| czech.utf32      | 3.178 GB/s                      | 15.721 GB/s                    | 7.801 GB/s                      |
+...
+| thai.utf32       | 3.191 GB/s                      | 15.455 GB/s                    | 7.842 GB/s                      |
+| turkish.utf32    | 3.191 GB/s                      | 15.086 GB/s                    | 7.809 GB/s                      |
+| vietnamese.utf32 | 3.182 GB/s                      | 15.317 GB/s                    | 7.807 GB/s                      |
+
+To compare results, use:
+
+$ ./benchmark_print.py old.txt new.txt
+|             dataset             | size [B] | iterations | old GB/s | new GB/s | speedup |
+| ------------------------------- | -------- | ---------- | -------- | -------- | ------- |
+| convert_utf32_to_latin1+haswell                                                         |
+| esperanto.utflatin32            |   328672 |      30000 |    77.14 |    88.81 | 1.15x   |
+| french.utflatin32               |  1729220 |      30000 |    75.26 |    92.39 | 1.23x   |
+| german.utflatin32               |   797324 |      30000 |    76.11 |    79.84 | 1.05x   |
+| portuguese.utflatin32           |  1086972 |      30000 |    84.12 |    92.64 | 1.10x   |
+"""
+
+
+def parse_file(path):
+    with open(path, 'r') as f:
+        return parse(f)
+
+
+def self_test():
+    rootdir = Path(__file__).parent / 'tests'
+
+    data = parse_file(rootdir / 'results.txt')
+    speed_comparison(data)
+
+    old = parse_file(rootdir / 'old.txt')
+    new = parse_file(rootdir / 'old.txt')
+    compare(new, old)
+
+
+def main():
+    args = sys.argv[1:]
+    if "-h" in args or "--help" in args:
+        print(HELP)
+        return
+
+    if "--test" in args:
+        print("running tests...")
+        self_test()
+        print("all OK")
+        return
+
+    n = len(args)
+
+    if n == 1:
+        data = parse_file(args[0])
+
+        print(speed_comparison(data))
+    elif n == 2:
+        old = parse_file(args[0])
+        new = parse_file(args[1])
+
+        print(compare(old, new))
+    else:
+        print(HELP)
+
+
+if __name__ == '__main__':
+    main()

package/deps/simdutf/scripts/check_feature_macros.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+import subprocess
+import re
+import os
+import argparse
+import sys
+from typing import List, Tuple
+
+def get_git_files(limit_to_src_include: bool) -> List[str]:
+    """Retrieve list of .cpp and .h files checked into the Git repository."""
+    try:
+        patterns = ['src/*.cpp', 'src/*.h', 'include/*.cpp', 'include/*.h'] if limit_to_src_include else ['*.cpp', '*.h']
+        result = subprocess.run(
+            ['git', 'ls-files'] + patterns,
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        files = result.stdout.splitlines()
+        if limit_to_src_include:
+            files = [f for f in files if f.startswith(('src/', 'include/'))]
+        return files
+    except subprocess.CalledProcessError as e:
+        print(f"Error running git ls-files: {e}")
+        return []
+
+def is_preprocessor_directive(line: str) -> bool:
+    """Check if the line contains a preprocessor directive (not in a comment)."""
+    line = re.sub(r'//.*$', '', line)
+    return bool(re.match(r'^\s*#', line))
+
+def extract_directive(lines: List[str], line_number: int) -> Tuple[str, str]:
+    """Extract directive type and condition (if any) from a preprocessor line."""
+    line = lines[line_number].strip()
+    # Sometimes, the condition may span multiple lines due to backslashes
+    # Handle multi-line conditions for #if directives
+    # We recursively gather lines if they end with a backslash
+    def build_full_condition(comment: str, line_number: int) -> str:
+        if comment.endswith('\\') and line_number + 1 < len(lines):
+            line_number += 1
+            return comment[:-1].strip() + ' ' + build_full_condition(lines[line_number].strip(), line_number)
+        else:
+            return comment.strip()
+    if line.startswith('#if '):
+        return 'if', build_full_condition(line[4:].strip(), line_number)
+    elif line.startswith('#ifdef '):
+        return 'ifdef', build_full_condition(line[7:].strip(), line_number)
+    elif line.startswith('#ifndef '):
+        return 'ifndef', build_full_condition(line[8:].strip(), line_number)
+    elif line.startswith('#endif'):
+        match = re.match(r'#endif\s*(?://\s*(.*))?$', line)
+        ## In some instances, the comment may be on the next line(s)
+        ## We use the following loop to gather such comments
+        ## The heuristic is that the next line starts with '//' and contains 'SIMDUTF_FEATURE'
+        ## Note that if we don't check for SIMDUTF_FEATURE, we may pick up unrelated comments.
+        comment = match.group(1).strip() if match and match.group(1) else ''
+        while line_number + 1 < len(lines):
+            next_line = lines[line_number + 1].strip()
+            if next_line.startswith('//') and 'SIMDUTF_FEATURE' in next_line:
+                comment_part = next_line[2:].strip()
+                comment = (comment + ' ' + comment_part).strip() if comment else comment_part
+                line_number += 1
+            else:
+                break
+        return 'endif', comment
+    return '', ''
+
+def is_feature_if_directive(condition: str) -> bool:
+    """Check if the #if condition contains a macro starting with SIMDUTF_FEATURE."""
+    return bool(re.search(r'\bSIMDUTF_FEATURE\w*\b', condition))
+
+def check_file(filename: str) -> List[str]:
+    """Check #if directives with SIMDUTF_FEATURE macros for matching #endif comments."""
+    errors = []
+    stack = []  # Stack of (directive, condition, is_feature, line_number)
+    statistics = {'if': 0, 'ifdef': 0, 'ifndef': 0, 'endif': 0}
+
+    try:
+        with open(filename, 'r', encoding='utf-8') as f:
+            lines = f.readlines()
+
+        for line_number, line in enumerate(lines):
+            if not is_preprocessor_directive(line):
+                continue
+
+            directive, condition = extract_directive(lines, line_number)
+            if not directive:
+                continue
+            statistics[directive] += 1
+
+            if directive in ('if', 'ifdef', 'ifndef'):
+                is_feature = directive == 'if' and is_feature_if_directive(condition)
+                stack.append((directive, condition, is_feature, line_number))
+            elif directive == 'endif' and stack:
+                orig_directive, orig_condition, is_feature, orig_line = stack.pop()
+                if is_feature:
+                    if not condition:
+                        errors.append(
+                            f"\033[31mERROR: {filename}:{line_number}: #endif missing comment (expected '{orig_condition}')\033[0m"
+                        )
+                    elif not re.match(r'SIMDUTF_FEATURE\w*', condition):
+                        errors.append(
+                            f"\033[31mERROR: {filename}:{line_number}: #endif comment '{condition}' does not start with SIMDUTF_FEATURE "
+                            f"(expected '{orig_condition}')\033[0m"
+                        )
+                    elif condition != orig_condition:
+                        errors.append(
+                            f"\033[31mERROR: {filename}:{line_number}: #endif comment '{condition}' does not match "
+                            f"#if condition '{orig_condition}' at line {orig_line}\033[0m"
+                        )
+
+        # Check for unclosed feature-related #if directives
+        for directive, condition, is_feature, line in stack:
+            if is_feature:
+                red_warning = f"\033[31mWARNING: {filename}:{line}: Unclosed #if '{condition}' at end of file\033[0m"
+                errors.append(red_warning)
+
+        return errors, statistics
+
+    except FileNotFoundError:
+        return [f"{filename}: File not found"], statistics
+    except UnicodeDecodeError:
+        return [f"{filename}: Unable to decode file (invalid encoding)"], statistics
+
+def main():
+    """Main function to check .cpp and .h files for SIMDUTF feature #if...#endif pairs."""
+    parser = argparse.ArgumentParser(description="Check #if...#endif pairs for SIMDUTF feature macros in .cpp and .h files.")
+    parser.add_argument('--limit', action='store_true', help="Limit checks to files in src/ and include/ directories")
+    args = parser.parse_args()
+
+    files = get_git_files(args.limit)
+    if not files:
+        print("No .cpp or .h files found in the Git repository" + (" in src/ or include/" if args.limit else "") + ".")
+        sys.exit(142)  # Exit with special code if no files are found, see https://github.com/simdutf/simdutf/issues/921
+
+    all_errors = []
+    statistics = {'if': 0, 'ifdef': 0, 'ifndef': 0, 'endif': 0}
+    for filename in files:
+        errors, file_stats = check_file(filename)
+        all_errors.extend(errors)
+        for key in statistics:
+            statistics[key] += file_stats.get(key, 0)
+
+    if all_errors:
+        print("Errors found:")
+        for error in all_errors:
+            print(error)
+        sys.exit(1)  # Exit with error code if errors are found
+    else:
+        for key, count in statistics.items():
+            print(f"Total #{key} directives: {count}")
+        print("All #if...#endif pairs for SIMDUTF feature macros are correctly matched with valid comments.")
+        sys.exit(0)  # Exit with success code
+
+if __name__ == "__main__":
+    main()

package/deps/simdutf/scripts/check_typos.sh

@@ -0,0 +1,13 @@
+#!/bin/sh
+
+#
+# checks for typos. run from the root dir.
+
+set -eu
+
+# this exits with nonzero status if it finds something, which terminates the script
+codespell \
+    --skip="./benchmarks/competition,./build,./fuzz/work"  \
+    -L vie,persan,fo,ans,larg,indx,shft,carryin
+
+echo "no typos detected!"

package/deps/simdutf/scripts/clang_format.sh

@@ -0,0 +1,35 @@
+#!/bin/sh
+#
+# clang formats all files in the repository.
+# certain files are excluded via .clang-format-ignore files
+# supported from clang format 18 upwards.
+
+set -eu
+
+cf=clang-format-18
+
+# Check if clang-format is installed
+if ! command -v $cf 2>&1 >/dev/null
+then
+    echo "Error: $cf not found. Please install Clang version 18."
+    echo "We recommend using the clang_format_docker.sh script."
+    exit 1
+fi
+
+if ! command -v git 2>&1 >/dev/null
+then
+    echo "Error: Git not found. Please install Git to use this script."
+    echo "You can get Git from:"
+    echo "  - Linux: Most distributions include Git; use your package manager (e.g., 'sudo apt-get install git')"
+    echo "  - macOS: Use Homebrew with 'brew install git'"
+    echo "  - Windows: Download from the official Git website"
+    exit 1
+fi
+
+gitroot="$(git rev-parse --show-toplevel)"
+
+cd "$gitroot"
+
+git ls-files -z | \
+    grep -z -E '(\.c|\.cpp|\.h)$' |\
+    xargs --null -P $(nproc) -n1 $cf -i

package/deps/simdutf/scripts/clang_format_docker.sh

@@ -0,0 +1,38 @@
+#!/bin/sh
+#
+# clang formats all files in the repository, using
+# a specific docker image.
+
+set -eu
+
+# Check if Docker is installed
+if ! command -v docker 2>&1 >/dev/null
+then
+    echo "Error: Docker not found. Please install Docker to use this script."
+    echo "You can get Docker from:"
+    echo "  - Linux: https://docs.docker.com/engine/install/"
+    echo "  - macOS: Use Homebrew with 'brew install --cask docker'"
+    echo "  - Windows: Download from Docker Desktop website"
+    exit 1
+fi
+
+# Check if Git is installed
+if ! command -v git 2>&1 >/dev/null
+then
+    echo "Error: Git not found. Please install Git to use this script."
+    echo "You can get Git from:"
+    echo "  - Linux: Most distributions include Git; use your package manager (e.g., 'sudo apt-get install git')"
+    echo "  - macOS: Use Homebrew with 'brew install git'"
+    echo "  - Windows: Download from the official Git website"
+    exit 1
+fi
+
+gitroot="$(git rev-parse --show-toplevel)"
+
+cd "$gitroot"
+
+docker run -v"$(pwd):/src"  \
+       --workdir /src \
+       -u "$(id -u $USER):$(id -g $USER)" \
+       ghcr.io/pauldreik/clang-format-18:latest \
+       scripts/clang_format.sh

package/deps/simdutf/scripts/common.py

@@ -0,0 +1,24 @@
+import textwrap
+import sys
+if sys.version_info[0] < 3:
+    print('You need to run this with Python 3')
+    sys.exit(1)
+
+indent = ' ' * 4
+
+def fill(text):
+    tmp = textwrap.fill(text)
+    return textwrap.indent(tmp, indent)
+
+def filltab(text):
+    tmp = textwrap.fill(text, width=120)
+    return textwrap.indent(tmp, '\t')
+
+def cpp_array_initializer(arr):
+    return '{%s}' % (', '.join(map(str, arr)))
+
+def compose2(f, g):
+    return lambda x: f(g(x))
+
+def cpp_arrayarray_initializer(arr):
+    return '{%s}' % (',\n '.join(map(compose2(filltab,cpp_array_initializer), arr)))

package/deps/simdutf/scripts/compilation_benchmark.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+#
+# runs a compilation benchmark
+
+import subprocess
+import tempfile
+import argparse
+import datetime
+import statistics
+
+
+class Sample:
+    def __init__(self, t0, t1, t2):
+        self._configure = (t1-t0).total_seconds()
+        self._compile = (t2-t1).total_seconds()
+
+# benchmarks compilation, returns the time consumption
+
+
+def measure_once(standard: int):
+    builddir = tempfile.TemporaryDirectory()
+    t0 = datetime.datetime.now()
+    subprocess.run(["cmake", f"-DSIMDUTF_CXX_STANDARD={standard}", "-DSIMDUTF_FAST_TESTS=On",
+                   "-B", builddir.name, "-GNinja"], stdout=subprocess.DEVNULL)
+    t1 = datetime.datetime.now()
+    subprocess.run(["cmake", "--build", builddir.name],
+                   stdout=subprocess.DEVNULL)
+    t2 = datetime.datetime.now()
+    # print(f"configure took {t1-t0}, build took {t2-t1}")
+    return Sample(t0, t1, t2)
+
+
+def benchmark_single(standard: int, repetitions: int = 3):
+    d = [measure_once(standard) for i in range(repetitions)]
+
+    m = statistics.median([e._configure for e in d])
+    print(f"median configure is {m:.3f}s")
+
+    m = statistics.median([e._compile for e in d])
+    print(f"median compile is {m:.3f}s")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog='compilation benchmark',
+        description='benchmarks compilation of simdutf')
+    parser.add_argument('--standard', type=int, default=23)
+    parser.add_argument('--repetitions', type=int, default=3)
+
+    args = parser.parse_args()
+    benchmark_single(standard=args.standard, repetitions=args.repetitions)
+
+
+if __name__ == '__main__':
+    main()