react-native-quick-crypto 1.0.19 → 1.1.0

package/deps/simdutf/benchmarks/competition/utf8lut/scripts/measure.py

@@ -0,0 +1,94 @@
+import subprocess, os, sys, re, shutil, json
+
+RunsCount = 10000
+
+ConvertToUtf16 = "FileConverter_msvc %s %s"
+
+Solutions_Decode = {
+    "trivial":    "FileConverter_msvc %s temp.out -b=0 -k={0} --small",
+    "utf8lut:1S": "FileConverter_msvc %s temp.out -b=3 -k={0} --small",
+    "utf8lut:4S": "FileConverter_msvc %s temp.out -b=3 -k={0}",
+    "u8u16": "u8u16_ssse3 %s temp.out {0}",
+    "utf8sse4": "utf8sse4 %s temp.out {0}",
+}
+Solutions_Encode = {
+    "trivial":    "FileConverter_msvc -s=utf16 -d=utf8 %s temp.out -b=0 -k={0} --small",
+    "utf8lut:1S": "FileConverter_msvc -s=utf16 -d=utf8 %s temp.out -b=3 -k={0} --small",
+    "utf8lut:4S": "FileConverter_msvc -s=utf16 -d=utf8 %s temp.out -b=3 -k={0}",
+}
+
+encode = (sys.argv[1] == 'encode')
+Solutions = (Solutions_Encode if encode else Solutions_Decode)
+for k,v in Solutions.items():
+    Solutions[k] = v.format(RunsCount)
+
+Tests = {
+    "[rnd1111:400000]": "rnd1111_utf8.txt",
+    "[rnd1110:500000]": "rnd1110_utf8.txt",
+    "chinese": "chinese_book.txt",
+    "russian": "war_and_piece.fb2",
+    "english": "english_book.txt",
+    "unicode": "unicode_table.html",
+}
+
+def log_name_of(sol_name, test_name):
+    log_name = sol_name + "__" + test_name
+    log_name = "logs/" + re.sub(r'[\W]', '_', log_name) + ".log"
+    return log_name
+
+def run_sol_test(sol_name, test_name, encode=False):
+    if encode:
+        subprocess.run((ConvertToUtf16 % (Tests[test_name], 'temp.in')).split(), stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        cmd = Solutions[sol_name] % 'temp.in'
+    else:
+        cmd = Solutions[sol_name] % Tests[test_name]
+    log_name = log_name_of(sol_name, test_name)
+    with open(log_name, 'wt') as f:
+        subprocess.run(cmd.split(), stdout=f, stderr=f)
+    return log_name
+
+def parse_log(log_name):
+    with open(log_name, 'rt') as f:
+        text = f.read()
+    external_result = None
+    internal_result = None
+    # typical overall measurement, added to every solution by myself
+    m = re.search(r'From total time\s+:\s+([\d.]+)\s+cyc/el\n', text)
+    if m:
+        external_result = float(m.group(1))
+    # internal timings in utf8lut
+    for m in re.finditer(r'slot \d+\s+(DECODE|ENCODE)\s+:\s+([\d.]+) cyc/el\s+(\d+) elems\n', text):
+        if int(m.group(3)) > 0:
+            internal_result = float(m.group(2))
+    # internal timings in u8u16
+    for m in re.finditer(r'BOM \d+: \d+ \(avg time: \d+ cyc/kElem\) Cumulative: \d+ \(avg: (\d+) cyc/kElem\)', text):
+        internal_result = float(m.group(1)) / 1000.0
+    return internal_result, external_result
+
+def main():
+    shutil.rmtree('logs', ignore_errors=True)
+    os.mkdir('logs')
+
+    #print(parse_log(run_sol_test("utf8lut:1S", "chinese")))
+    #print(parse_log(run_sol_test("u8u16", "chinese")))
+    #print(parse_log(run_sol_test("utf8sse4", "chinese")))
+
+    jsonall = {}
+    jsonall['solutions'] = list(Solutions.keys())
+    jsonall['tests'] = list(Tests.keys())
+    data = jsonall['xdata'] = {}
+    for test in Tests:
+        data[test] = {}
+        for sol in Solutions:
+            print("Test %s, Sol %s:" % (test, sol), end="", flush=True)
+            log_name = run_sol_test(sol, test, encode)
+            print(" finished: ", end="", flush=True)
+            result = parse_log(log_name)
+            print(result[0], '/', result[1], flush=True)
+            data[test][sol] = (result[0], result[1], log_name)
+
+    with open("logs/results.json", "wt") as f:
+        json.dump(jsonall, f, indent=2, sort_keys=True)
+
+if __name__ == "__main__":
+    main()

package/deps/simdutf/benchmarks/competition/utf8lut/scripts/resize.py

@@ -0,0 +1,20 @@
+import sys, os
+
+filename = sys.argv[1]
+want_size = int(sys.argv[2])
+
+buff_size = 2**20
+remains = want_size
+with open(filename + '.tmp', 'wb') as fo:
+    while remains > 0:
+        with open(filename, 'rb') as fi:
+            while remains > 0:
+                chunk = fi.read(buff_size)
+                if len(chunk) == 0:
+                    break
+                if len(chunk) > remains:
+                    chunk = chunk[:remains]
+                fo.write(chunk)
+                remains -= len(chunk)
+
+os.replace(filename + '.tmp', filename)

package/deps/simdutf/benchmarks/competition/utf8lut/scripts/wipe_all.cmd

@@ -0,0 +1,2 @@
+call wipe_interm.cmd
+del *.exe *.pdb *.dll *.lib *.txt *.bin

package/deps/simdutf/benchmarks/competition/utf8lut/scripts/wipe_interm.cmd

@@ -0,0 +1 @@
+del *.obj *.asm *.ilk *.exp vc*.pdb

package/deps/simdutf/benchmarks/competition/utf8lut/src/base/CustomMemcpy.h

@@ -0,0 +1,75 @@
+#ifdef MEMCPY_READ_NT
+    #define MEMCPY_READ_FUNC _mm_stream_load_si128  //SSE 4.1
+    #define MEMCPY_READ_SUFFIX nt
+#else
+    #define MEMCPY_READ_FUNC _mm_loadu_si128
+    #define MEMCPY_READ_SUFFIX t
+#endif
+
+#ifdef MEMCPY_WRITE_NT
+    #define MEMCPY_WRITE_FUNC _mm_stream_si128
+    #define MEMCPY_WRITE_SUFFIX nt
+#else
+    #define MEMCPY_WRITE_FUNC _mm_storeu_si128
+    #define MEMCPY_WRITE_SUFFIX t
+#endif
+
+#define MEMCPY_CONCAT(a, b, c) a##_##b##_##c
+#define MEMCPY_JOIN(a, b, c) MEMCPY_CONCAT(a, b, c)
+
+inline void MEMCPY_JOIN(CustomMemcpy, MEMCPY_WRITE_SUFFIX, MEMCPY_READ_SUFFIX)(char *dst, const char *src, size_t num) {
+#ifdef MEMCPY_READ_NT
+    while (num && (size_t(src) & 0xF)) {
+        *dst++ = *src++;
+        num--;
+    }
+#endif
+#ifdef MEMCPY_WRITE_NT
+    while (num && (size_t(dst) & 0xF)) {
+        *dst++ = *src++;
+        num--;
+    }
+#endif
+    while (num >= 128) {
+        #define MEMCPY_READ_X(k) __m128i reg##k = MEMCPY_READ_FUNC((__m128i*)(src + 16*k))
+        #define MEMCPY_WRITE_X(k) MEMCPY_WRITE_FUNC((__m128i*)(dst + 16*k), reg##k)
+        MEMCPY_READ_X(0);
+        MEMCPY_READ_X(1);
+        MEMCPY_READ_X(2);
+        MEMCPY_READ_X(3);
+        MEMCPY_WRITE_X(0);
+        MEMCPY_WRITE_X(1);
+        MEMCPY_WRITE_X(2);
+        MEMCPY_WRITE_X(3);
+        MEMCPY_READ_X(4);
+        MEMCPY_READ_X(5);
+        MEMCPY_READ_X(6);
+        MEMCPY_READ_X(7);
+        MEMCPY_WRITE_X(4);
+        MEMCPY_WRITE_X(5);
+        MEMCPY_WRITE_X(6);
+        MEMCPY_WRITE_X(7);
+        dst += 128;
+        src += 128;
+        num -= 128;
+        #undef MEMCPY_READ_X
+        #undef MEMCPY_WRITE_X
+    }
+#ifdef MEMCPY_WRITE_NT
+    _mm_sfence();
+#endif
+    memcpy(dst, src, num);
+}
+
+#undef MEMCPY_READ_FUNC
+#undef MEMCPY_READ_SUFFIX
+#undef MEMCPY_WRITE_FUNC
+#undef MEMCPY_WRITE_SUFFIX
+#undef MEMCPY_CONCAT
+#undef MEMCPY_JOIN
+#ifdef MEMCPY_READ_NT
+    #undef MEMCPY_READ_NT
+#endif
+#ifdef MEMCPY_WRITE_NT
+    #undef MEMCPY_WRITE_NT
+#endif

package/deps/simdutf/benchmarks/competition/utf8lut/src/base/PerfDefs.h

@@ -0,0 +1,47 @@
+#pragma once
+
+//----------------------------COMPILER-SPECIFIC
+
+#ifdef _MSC_VER
+    #define FORCEINLINE __forceinline
+    #define NOINLINE __declspec(noinline)
+    #define ALIGN(n) __declspec(align(n))
+    #define RESTRICT __restrict
+#else
+    #define FORCEINLINE __attribute__((always_inline)) inline
+    #define NOINLINE __attribute__((noinline))
+    #define ALIGN(n) __attribute__((aligned(n)))
+    #define RESTRICT __restrict__
+#endif
+#define CACHE_LINE 64
+#define CACHEALIGN ALIGN(CACHE_LINE)
+
+//----------------------------COMMON-MACROS
+
+//common macros
+#define ALIGNDOWN(x, b) ((x) / (b) * (b))
+#define ALIGNUP(x, b) ALIGNDOWN(((x) + (b) - 1), b)
+#define TPNT(x, type, offset) ((type *)(((char *)(x)) + offset))
+#define TREF(x, type, offset) TPNT(x, type, offset)[0]
+#define DMIN(a, b) ((a) < (b) ? (a) : (b))
+#define DMAX(a, b) ((a) > (b) ? (a) : (b))
+
+//----------------------------SSE-MACROS
+
+/*#ifdef SSE4   //note: ptest instruction is slower than pmovmskb + cmp
+    #include "smmintrin.h"
+    #define _mm_cmp_allzero(reg) _mm_test_all_zeros(reg, reg)
+    #define _mm_cmp_allone(reg) _mm_test_all_ones(reg)
+#else*/
+    #define _mm_cmp_allzero(reg) (_mm_movemask_epi8(reg) == 0)
+    #define _mm_cmp_allone(reg) (_mm_movemask_epi8(reg) == 0xFFFF)
+//#endif
+
+/*#if defined(__SSE4__) || defined(__AVX__)
+    #define _mm_packus_epi32_(a, b) _mm_packus_epi32(a, b)
+#else
+    #define _mm_packus_epi32_(a, b) _mm_xor_si128(\
+        _mm_shuffle_epi8(a, _mm_setr_epi8(0, 1, 4, 5, 8, 9, 12, 13, -1, -1, -1, -1, -1, -1, -1, -1)),\
+        _mm_shuffle_epi8(b, _mm_setr_epi8(-1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 4, 5, 8, 9, 12, 13))\
+    )
+#endif*/

package/deps/simdutf/benchmarks/competition/utf8lut/src/base/Timing.cpp

@@ -0,0 +1,17 @@
+#include "base/Timing.h"
+
+#ifdef TIMING
+
+TimingData timingData = TimingData();
+void TimingPrintAll(FILE *f) {
+    #define TIMING_X_PRINT(name, idx) \
+        if (idx == TIMING_MAX) return; \
+        fprintf(f, "slot %d %10s : %6.3f cyc/el  %12" PRIu64 " elems\n", \
+            idx, #name, \
+            timingData.totalTime[idx] / (timingData.totalElems[idx] + 1e-9), \
+            timingData.totalElems[idx] \
+        );
+    TIMING_SLOTS(TIMING_X_PRINT);
+}
+
+#endif

package/deps/simdutf/benchmarks/competition/utf8lut/src/base/Timing.h

@@ -0,0 +1,76 @@
+#pragma once
+
+#ifdef TIMING
+//define all this stuff only if asked for
+
+#include <stdint.h>
+#include <assert.h>
+#include <stdio.h>
+
+#ifdef _MSC_VER
+    #define PRIu64 "I64u"
+    #define PRId64 "I64d"
+#else
+    #define __STDC_FORMAT_MACROS 1
+    #include <inttypes.h>
+#endif
+
+#ifdef _MSC_VER
+    #include <intrin.h>
+#else
+    #include <x86intrin.h>
+#endif
+static inline uint64_t get_ticks() {
+    return __rdtsc();
+}
+
+#define TIMING_SLOTS(X) \
+    X(DECODE, 1) \
+    X(ENCODE, 2) \
+    X(MAX, 3)
+
+//======================================================
+
+#define CONCAT(x, y) x##y
+
+#define TIMING_X_DEFINE(name, idx) \
+    static const int CONCAT(TIMING_, name) = idx;
+TIMING_SLOTS(TIMING_X_DEFINE);
+
+struct TimingData {
+    uint64_t totalTime[TIMING_MAX];
+    uint64_t totalElems[TIMING_MAX];
+    uint64_t startTime[TIMING_MAX];
+};
+
+extern TimingData timingData;
+
+//======================================================
+
+#define TIMING_START(name) { \
+    int slot = CONCAT(TIMING_, name); \
+    uint64_t &startTime = timingData.startTime[slot]; \
+    startTime = get_ticks(); \
+}
+
+#define TIMING_END(name, elems) { \
+    uint64_t endTime = get_ticks(); \
+    int slot = CONCAT(TIMING_, name); \
+    uint64_t &startTime = timingData.startTime[slot]; \
+    assert(startTime != 0); \
+    timingData.totalTime[slot] += endTime - startTime; \
+    timingData.totalElems[slot] += uint64_t(elems); \
+    startTime = 0; \
+}
+
+void TimingPrintAll(FILE *f);
+#define TIMING_PRINT(f) TimingPrintAll(f);
+
+#else
+//if not asked (TIMING undefined), then define empty macros
+
+#define TIMING_START(name)
+#define TIMING_END(name, elems)
+#define TIMING_PRINT(f)
+
+#endif

package/deps/simdutf/benchmarks/competition/utf8lut/src/buffer/AllProcessors.cpp

@@ -0,0 +1,35 @@
+// Note: this source file contains instantiations of all possible processors.
+// You should NOT link it in your project.
+// It is used mostly for testing purposes.
+
+#include "buffer/ProcessorSelector.h"
+
+BaseBufferProcessor* GenerateProcessor(int srcFormat, int dstFormat, int maxBytes, int checkMode, int multiplier, int *errorCounter) {
+    #define TRY_PROC(from, to, maxB, mode, mult) \
+        if (srcFormat == from && dstFormat == to && maxBytes == maxB && checkMode == mode && multiplier == mult) \
+            res = ProcessorSelector<from, to>::template WithOptions<mode, maxB, mult>::Create(errorCounter);
+
+    #define TRY_OPT(from, to, maxB, mode) \
+        TRY_PROC(from, to, maxB, mode, 1); \
+        TRY_PROC(from, to, maxB, mode, 4);
+
+    #define TRY_DB(from, to, maxB) \
+        TRY_OPT(from, to, maxB, cmFast); \
+        TRY_OPT(from, to, maxB, cmFull); \
+        TRY_OPT(from, to, maxB, cmValidate);
+
+    #define TRY_DIR(from, to) \
+        TRY_PROC(from, to, 0, 2, 1); \
+        TRY_DB(from, to, 1); \
+        TRY_DB(from, to, 2); \
+        TRY_DB(from, to, 3);
+
+    BaseBufferProcessor *res = 0;
+
+    TRY_DIR(dfUtf8, dfUtf16);
+    TRY_DIR(dfUtf8, dfUtf32);
+    TRY_DIR(dfUtf16, dfUtf8);
+    TRY_DIR(dfUtf32, dfUtf8);
+
+    return res;
+}

package/deps/simdutf/benchmarks/competition/utf8lut/src/buffer/BaseBufferProcessor.cpp

@@ -0,0 +1,117 @@
+#include "../buffer/BaseBufferProcessor.h"
+#include "../buffer/ProcessorPlugins.h"
+#include <string.h>
+#include <assert.h>
+#include <limits.h>
+
+BaseBufferProcessor::BaseBufferProcessor() {
+    errorCallback = 0;
+    errorContext = 0;
+    Clear();
+}
+BaseBufferProcessor::~BaseBufferProcessor() {
+}
+
+void BaseBufferProcessor::Clear() {
+    inputBuffer = 0;
+    inputSize = 0;
+    memset(outputBuffer, 0, sizeof(outputBuffer));
+    memset(outputSize, 0, sizeof(outputSize));
+    inputDone = 0;
+    memset(outputDone, 0, sizeof(outputDone));
+    SetHint();
+    pluginsCount = 0;
+}
+
+void BaseBufferProcessor::SetInputBuffer(const char *ptr, int size) {
+    inputBuffer = ptr;
+    inputSize = size;
+}
+
+void BaseBufferProcessor::SetOutputBuffer(char *ptr, int size, int index) {
+    assert(index >= 0 && index < MaxStreamsCount);
+    outputBuffer[index] = ptr;
+    outputSize[index] = size;
+}
+#ifdef __GNUC__
+__attribute__((unused))
+#endif 
+bool BaseBufferProcessor::CheckBuffers() const {
+    int streams = GetStreamsCount();
+    //check input buffer validity
+    if (!inputBuffer || inputSize < 1 || inputSize > GetBufferMaxSize())
+        return false;
+    //check output buffers validity
+    for (int i = 0; i < streams; i++)
+        if (!outputBuffer[i] || outputSize[i] < 1 || outputSize[i] > GetBufferMaxSize())
+            return false;
+    //check for overlapping
+    for (int i = -1; i < streams; i++)
+        for (int j = i+1; j < streams; j++) {
+            const char *leftA = (i < 0 ? inputBuffer : outputBuffer[i]);
+            const char *rightA = leftA + (i < 0 ? inputSize : outputSize[i]);
+            const char *leftB = outputBuffer[j];
+            const char *rightB = leftB + outputSize[j];
+            if (leftA >= rightB || leftB >= rightA)
+                continue;
+            return false;
+        }
+    return true;
+}
+
+int BaseBufferProcessor::GetBufferMaxSize() const {
+    return INT_MAX / 8;
+}
+
+void BaseBufferProcessor::SetHint(bool isLastBlock) {
+    lastBlockMode = isLastBlock;
+}
+
+bool BaseBufferProcessor::Process() {
+    for (int i = 0; i < pluginsCount; i++)
+        plugins[i]->Pre();
+
+    assert(CheckBuffers());
+    inputDone = 0;
+    memset(outputDone, 0, sizeof(outputDone));
+
+    bool res = _Process();
+    while (!res && errorCallback) {
+        const char *inputPtr = inputBuffer + inputDone;
+        char *outputPtr = outputBuffer[0] + outputDone[0];
+        bool fixed = errorCallback(errorContext, inputPtr, inputSize - inputDone, outputPtr, outputSize[0] - outputDone[0]);
+        inputDone = inputPtr - inputBuffer;
+        outputDone[0] = outputPtr - outputBuffer[0];
+        assert(inputDone >= 0 && inputDone <= inputSize);
+        assert(outputDone[0] >= 0 && outputDone[0] <= outputSize[0]);
+        if (!fixed)
+            break;
+        res = _Process();
+    }
+
+    for (int i = pluginsCount-1; i >= 0; i--)
+        plugins[i]->Post();
+
+    return res;
+}
+
+int BaseBufferProcessor::GetInputDoneSize() const {
+    return inputDone;
+}
+
+int BaseBufferProcessor::GetOutputDoneSize(int index) const {
+    return outputDone[index];
+}
+
+void BaseBufferProcessor::AddPlugin(BasePlugin &addedPlugin) {
+    assert(pluginsCount < MaxPluginsCount);
+    plugins[pluginsCount++] = &addedPlugin;
+}
+
+bool BaseBufferProcessor::SetErrorCallback(pfErrorCallback callback, ctxErrorCallback context) {
+    if (GetStreamsCount() > 1)
+        return false;   //not supported
+    errorCallback = callback;
+    errorContext = context;
+    return true;
+}