react-native-quick-crypto 1.0.19 → 1.1.0

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

@@ -0,0 +1,210 @@
+#pragma once
+
+#include <string.h>
+#include <assert.h>
+
+class BasePlugin;
+
+// BaseBufferProcessor: base class for any processor, which can convert buffers of data.
+// As soon as you have created a suitable processor object,
+// only this common interface is necessary to work with it.
+// See ProcessorSelector.h for information about choosing and creating a processor.
+//
+// Most of the methods of processor are used only to get information or to configure it.
+// The method 'Process' is the only one which actually performs the conversion.
+// Everything must be properly configured by the time it is called.
+// Among the state-configuring methods, only the following ones are mandatory (unless you use plugins):
+//   SetInputBuffer, SetOutputBuffer;
+// Among the info-quering methods, you will surely need the following ones:
+//   GetOutputBufferMinSize, GetInputDoneSize, GetOutputDoneSize;
+//
+// One input buffer and one (or several) output buffer(s) must be set for conversion.
+// Note that processor neither has any buffers within it, nor owns the buffers passed to it.
+// The caller is responsible for managing lifetime of the buffers, processor only saves references to them.
+//
+// Each call of 'Process' method performs conversion of the input buffer.
+// Below you can see the plan of all the buffers and how they are filled during 'Process' call.
+// There is a major difference here between single-stream and multi-stream conversion.
+// In multi-stream case, the input data is split into chunks, which are converted simultaneously,
+// Each stream converts its own chunk and writes conversion result to its own output buffer.
+//
+// 
+//           input buffer                                     input buffer                         ;
+//      +-------------------+                 \          +-----------------|-+                     ;
+//      |%%%%%%%%%%%%%%%%%%%|                  \         |.................|%|                     ;
+//      +-------------------+         ----------\        +-----------------|-+                     ;
+//                                      Process  >                         ^                       ;
+//           output buffer            ----------/             output buffer                        ;
+//   +---------------------------+             /      +------------------|--------+                ;
+//   |...........................|            /       |##################|........|                ;
+//   +---------------------------+                    +------------------|--------+                ;
+//                                                     0123456789ABCDEFGH^
+// (above: single-stream conversion)
+//   '.' -- nonexisting, undefined, or no-longer-necessary data
+//   '%' -- the input data, to be converted
+//   '#' -- the output data, already converted
+//   '^' -- a pointer showing how many bytes were read or written
+//   '012...AB...' --- the order of output data (within the message)
+// (below: multi-stream conversion, 4 streams)
+//
+//           input buffer                                     input buffer                         ;
+//         +--------------+                   \             +-------------|+                       ;
+//         |%%%%%%%%%%%%%%|                    \            |.............||                       ;
+//         +--------------+           ----------\           +-------------|+                       ;
+//                                      Process  >                        ^                        ;
+//           output buffers           ----------/             output buffers                       ;
+//  +-----+ +-----+ +-----+ +-----+            /     +---|-+ +--|--+ +----|+ +---|-+               ;
+//  |.....| |.....| |.....| |.....|           /      |###|.| |##|..| |####|| |###|.|               ;
+//  +-----+ +-----+ +-----+ +-----+                  +---|-+ +--|--+ +----|+ +---|-+               ;
+//                                                    012^    34^     5678^   9AB^                 ;
+//
+//
+// Plugins can be used to simplify setting input and output buffers,
+// but their usage is completely optional.
+// Each plugin has two methods: both of them are called inside 'Process' method.
+// One of them is called before conversion, and one of them is called after it.
+// See more details in ProcessorPlugins.h.
+//
+// When an encoding error is met in the input data,
+// the default behavior of a validating processor is to simply stop before it.
+// If you want to convert invalid input by fixing the encoding errors, then you should set an error callback.
+// You can read more about it and find some ready-to-use error callbacks in ProcessorSelector.h.
+// 
+class BaseBufferProcessor {
+public:
+    //maximum possible number of output streams among all available processors
+    static const int MaxStreamsCount = 4;
+    //a hard cap on the number of plugins that may be attached to a processor
+    static const int MaxPluginsCount = 2;
+
+    virtual ~BaseBufferProcessor();
+
+    // Resets processor to its default state.
+    // Exception: error callback is NOT changed (see details below).
+    void Clear();
+
+    // Returns how many output buffers are used.
+    // Usually a processor uses only one output buffer (i.e. single stream).
+    // The only exception is 4-stream buffer decoder, which converts to 4 buffers.
+    // Note: the same value is always returned for a given processor.
+    virtual int GetStreamsCount() const = 0;
+
+    // Specifies where to get input data from.
+    // A pointer to an external buffer must be passed.
+    // Note: here and below all buffer sizes are in bytes.
+    void SetInputBuffer(const char *ptr, int size);
+
+    // Specifies where to write output data to (for single stream).
+    // A pointer to an external buffer must be passed.
+    // Parameter 'index' is the index of the output stream being configured.
+    // In case of single-stream processor, only one output buffer is set.
+    // In case of multi-stream processor, output buffer must be set separately for each stream.
+    void SetOutputBuffer(char *ptr, int size, int index = 0);
+
+    // Checks whether all input + output buffers are configured correctly.
+    // Returns false if:
+    //   * one of the buffers is not set;
+    //   * one of the buffers has invalid size (empty or insanely large);
+    //   * the output buffers are not large enough to hold converted result;
+    //   * some buffers overlap;
+    bool CheckBuffers() const;
+
+    // Returns the recommended size of an input buffer.
+    // This size is considered to be good for performance.
+    // Using much smaller of much larger buffer would slow down conversion.
+    virtual int GetInputBufferRecommendedSize() const = 0;
+
+    // Returns minimal allowed size of each output buffer, given the size of the input buffer.
+    // In case of a multi-stream processor, every ONE output buffer
+    // must have at least this size (and NOT all of them together).
+    // This function does NOT depend on the state of processor,
+    // and for a given processor it always returns the same number given the same argument.
+    // The output depends on the input almost linearly (plus some constant overhead and some rounding).
+    // Note: the argument may exceed maximal allowed buffer size.
+    virtual long long GetOutputBufferMinSize(long long inputSize) const = 0;
+
+    // Returns maximal allowed size of any buffer involved.
+    // This size cap is orders of magnitude greater that the recommended size anyway.
+    // The returned value always stays the same for a given processor.
+    int GetBufferMaxSize() const;
+
+    // Sets a hint whether the next block of data would be the last one or not.
+    // If set to true, then maximum number of code points is always converted (a few bytes may remain).
+    // If you set it to false, then processor may leave a few complete code points unconverted (only in case of success).
+    // If the input data is invalid, then the hint does not matter (as if hint = true).
+    // Note: the last call of 'Process' method must be done with this hint set to true!
+    void SetHint(bool isLastBlock = true);
+
+    // Runs convertion of the preconfigured input buffer.
+    // The output is written into preconfigured output buffer (or bufferS in multi-stream case).
+    // The method returns:
+    //   'true':
+    //      Some prefix of the input buffer has been successfully converted.
+    //      See method SetHint for details about how the length of the prefix is chosen.
+    //   'false':
+    //      Some prefix of the input buffer has been successfully converted,
+    //      but the data immediately after it cannot be converted (because it is invalid).
+    // Note that if you set error callback (see below), then even invalid data is converted successfully.
+    // In order to learn how many bytes were converted, use methods GetInputDoneSize and GetOutputDoneSize.
+    bool Process();
+
+    // Returns how many bytes from the input buffer were successfully converted during the last 'Process' call.
+    int GetInputDoneSize() const;
+
+    // Returns how many bytes were written to the output buffer during the last 'Process' call.
+    // In case of multi-stream processor, you must specify 'index' of the output buffer.
+    // Then number of bytes written to this specific buffer is returned.
+    // If you concatenate the data written to all the output buffers (in their natural order),
+    // you will obtain the real result of the conversion.
+    int GetOutputDoneSize(int index = 0) const;
+
+    // Adds a plugin to processor.
+    // You should NOT call this method directly,
+    // because it is usually called in plugin's constructor.
+    // See ProcessorPlugins.h for more information.
+    void AddPlugin(BasePlugin &addedPlugin);
+
+    // The error callback receives an opaque value of this type.
+    typedef void *ctxErrorCallback;
+    // This is the type of the error callback function.
+    //   context: the opaque value set alongside the function pointer
+    //   srcBuffer: current pointer to the input data (everything before it has been converted)
+    //   srcBytes: how many bytes of input data remain ahead (unconverted yet)
+    //   dstBuffer: current pointer to the output data (the converted data is exactly before it)
+    //   dstBytes: how many bytes of space are left in the output buffer
+    // If true is returned, then conversion is continued as if no error happened.
+    // If false is returned, then conversion stops (just like it stops if no error callback is set)
+    // Both srcBuffer and dstBuffer can be updated by the callback,
+    // but note that moving output pointer too far may lead to buffer overflows in future.
+    typedef bool (*pfErrorCallback)(ctxErrorCallback context, const char *&srcBuffer, int srcBytes, char *&dstBuffer, int dstBytes);
+    // Sets a callback which would be fired each time processor detects invalid input data.
+    // The 'context' argument is passed to the callback function on every call.
+    // Error correction is not supported for processors with multi-stream output.
+    // Note: error callback is NOT cleared when 'Clear' method is called.
+    bool SetErrorCallback(pfErrorCallback callback = 0, ctxErrorCallback context = 0);
+    
+private:
+    virtual bool _Process() = 0;
+
+    //plugins attached
+    BasePlugin *plugins[MaxPluginsCount];
+    int pluginsCount;
+    //error callback (if present)
+    pfErrorCallback errorCallback;
+    ctxErrorCallback errorContext;
+
+protected:  //accessed in implementations
+    BaseBufferProcessor();
+
+    //input buffer
+    const char *inputBuffer;
+    int inputSize;
+    //output buffers (one per stream)
+    char *outputBuffer[MaxStreamsCount];
+    int outputSize[MaxStreamsCount];
+    //the hint: would next block be last
+    bool lastBlockMode;
+    //how much bytes were processed
+    int inputDone;
+    int outputDone[MaxStreamsCount];
+};

package/deps/simdutf/benchmarks/competition/utf8lut/src/buffer/BufferDecoder.h

@@ -0,0 +1,158 @@
+#pragma once
+
+#include <stdint.h>
+#include <assert.h>
+#include "../base/PerfDefs.h"
+#include "../core/DecoderLut.h"
+#include "../core/DecoderProcess.h"
+#include "../core/ProcessTrivial.h"
+#include "../base/Timing.h"
+#include "../buffer/BaseBufferProcessor.h"
+
+FORCEINLINE const char *FindUtf8Border(const char *pSource) {
+    for (int i = 0; i < 4; i++) {
+        uint8_t byte = pSource[i];
+        if ((byte & 0x80U) == 0x00U)
+            return pSource + i;
+        if ((byte & 0xC0U) == 0xC0U)
+            return pSource + i;
+    }
+    //four continuation bytes in a row
+    //split at the end, so that left half is surely invalid
+    return pSource + 4;
+}
+
+/**params:
+ * MaxBytes = 0, 1, 2, 3
+ * StreamsNum = 1, 4
+ * Mode = fast, full, validate
+ * OutputType = 2, 4
+ */
+
+enum DecoderMode {
+    dmFast,     //decode only byte lengths under limit, no checks
+    dmFull,     //decode any UTF-8 chars (with fallback to slow version)
+    dmValidate, //decode any UTF-8 chars, validate input
+    dmAllCount, //helper
+};
+
+template<int MaxBytes, int OutputType, int Mode, int StreamsNum>
+class BufferDecoder : public BaseBufferProcessor {
+public:
+    static const int StreamsNumber = DMAX(StreamsNum, 1);
+
+private:
+    static const bool Validate = (Mode == dmValidate);
+
+    static FORCEINLINE bool ProcessSimple(const char *&inputPtr, const char *inputEnd, char *&outputPtr, bool isLastBlock) {
+        bool ok = true;
+        const DecoderLutEntry<Validate> *RESTRICT ptrTable = DecoderLutTable<Validate>::GetArray();
+        while (inputPtr <= inputEnd - 16) {
+            ok = DecoderCore<MaxBytes, Mode != dmFast, Mode == dmValidate, OutputType>()(inputPtr, outputPtr, ptrTable);
+            if (!ok) {
+                if (Mode != dmFast)
+                    ok = DecodeTrivial<OutputType>(inputPtr, inputPtr + 16, outputPtr);
+                if (!ok) break;
+            }
+        }
+        if (isLastBlock)
+            ok = DecodeTrivial<OutputType>(inputPtr, inputEnd, outputPtr);
+        return ok;
+    }
+
+    static FORCEINLINE void SplitRange(const char *buffer, int size, const char *splits[]) {
+        splits[0] = buffer;
+        splits[StreamsNumber] = buffer + size;
+        for (int k = 1; k < StreamsNumber; k++)
+            splits[k] = FindUtf8Border(buffer + uint32_t(k * size) / StreamsNumber);
+    }
+public:
+
+    BufferDecoder() {
+        static_assert(MaxBytes >= 0 && MaxBytes <= 3, "MaxBytes must be between 0 and 3");
+        static_assert(OutputType == 2 || OutputType == 4, "OutputType must be either 2 or 4");
+        static_assert(Mode >= 0 && Mode <= dmAllCount, "Mode must be from DecoderMode enum");
+        static_assert(StreamsNum == 1 || StreamsNum == 4, "StreamsNum can be only 1 or 4");
+        static_assert(MaxBytes > 0 || StreamsNum == 1, "StreamNum must be 1 when MaxBytes = 0");
+    }
+
+    virtual int GetStreamsCount() const {
+        return StreamsNumber;
+    }
+    virtual int GetInputBufferRecommendedSize() const {
+        return 1<<16;   //64KB
+    }
+    virtual long long GetOutputBufferMinSize(long long inputSize) const {
+        return (inputSize / StreamsNumber + 4) * OutputType;
+    }
+
+    virtual bool _Process() {
+        TIMING_START(DECODE);
+        static const int MinBytesPerStream = 32;    //more than 16 after split
+        if (StreamsNum > 1 && inputSize >= StreamsNum * MinBytesPerStream) {
+            assert(StreamsNum == 4);
+            const char *splits[StreamsNum + 1];
+            SplitRange(inputBuffer, inputSize, splits);
+            const DecoderLutEntry<Validate> *RESTRICT ptrTable = DecoderLutTable<Validate>::GetArray();
+            #define STREAM_START(k) \
+                const char *inputStart##k = splits[k]; \
+                const char *inputEnd##k = splits[k+1]; \
+                const char *inputPtr##k = inputStart##k; \
+                char *outputPtr##k = outputBuffer[k]; \
+                bool ok##k;
+            STREAM_START(0)
+            STREAM_START(1)
+            STREAM_START(2)
+            STREAM_START(3)
+            while (1) {
+                #define STREAM_CHECK(k) \
+                    if (inputPtr##k > inputEnd##k - 16) \
+                        break;
+                STREAM_CHECK(0);
+                STREAM_CHECK(1);
+                STREAM_CHECK(2);
+                STREAM_CHECK(3);
+                #define STREAM_STEP(k) \
+                    ok##k = DecoderCore<MaxBytes, Mode != dmFast, Mode == dmValidate, OutputType>()(inputPtr##k, outputPtr##k, ptrTable); \
+                    if (!ok##k) goto slow;
+                STREAM_STEP(0);
+                STREAM_STEP(1);
+                STREAM_STEP(2);
+                STREAM_STEP(3);
+slow:
+                #define STREAM_SLOW(k) \
+                    if (!ok##k && Mode != dmFast) \
+                        ok##k = DecodeTrivial<OutputType>(inputPtr##k, inputPtr##k + 16, outputPtr##k); \
+                    if (!ok##k) break;
+                STREAM_SLOW(0);
+                STREAM_SLOW(1);
+                STREAM_SLOW(2);
+                STREAM_SLOW(3);
+            }
+            #define STREAM_FINISH(k) \
+                ok##k = ProcessSimple(inputPtr##k, inputEnd##k, outputPtr##k, true); \
+                inputDone = int(inputPtr##k - inputBuffer); \
+                outputDone[k] = int(outputPtr##k - outputBuffer[k]); \
+                if (!ok##k || (k+1 < StreamsNum && inputPtr##k != inputEnd##k)) \
+                    return false;
+            STREAM_FINISH(0);
+            STREAM_FINISH(1);
+            STREAM_FINISH(2);
+            STREAM_FINISH(3);
+        }
+        else {
+            const char *inputPtr = inputBuffer + inputDone;
+            char *outputPtr = outputBuffer[0] + outputDone[0];
+            bool ok;
+            if (MaxBytes > 0)
+                ok = ProcessSimple(inputPtr, inputBuffer + inputSize, outputPtr, lastBlockMode);
+            else
+                ok = DecodeTrivial<OutputType>(inputPtr, inputBuffer + inputSize, outputPtr);
+            inputDone = int(inputPtr - inputBuffer);
+            outputDone[0] = int(outputPtr - outputBuffer[0]);
+            if (!ok) return false;
+        }
+        TIMING_END(DECODE, inputDone);
+        return true;
+    }
+};

package/deps/simdutf/benchmarks/competition/utf8lut/src/buffer/BufferEncoder.h

@@ -0,0 +1,104 @@
+#pragma once
+
+#include <stdint.h>
+#include <assert.h>
+#include "../base/PerfDefs.h"
+#include "../core/EncoderLut.h"
+#include "../core/EncoderProcess.h"
+#include "../core/ProcessTrivial.h"
+#include "../base/Timing.h"
+#include "../buffer/BaseBufferProcessor.h"
+
+/**params:
+ * MaxBytes = 0, 1, 2, 3
+ * UnrollNum = 1, 4
+ * Mode = fast, full, validate
+ * InputType = 2, 4
+ */
+
+enum EncoderMode {
+    emFast,     //encode only byte lengths under limit, no checks
+    emFull,     //encode any UTF-8 chars (with fallback to slow version)
+    emValidate, //encode any UTF-8 chars, validate input
+    emAllCount, //helper
+};
+//Note: emValidate and emFull are completely equivalent
+
+template<int MaxBytes, int InputType, int Mode, int UnrollNum>
+class BufferEncoder : public BaseBufferProcessor {
+public:
+    static const int StreamsNumber = 1;
+
+private:
+    static const int InputMinChunk = 8 * InputType;
+    static const int InputUnrollChunk = InputMinChunk * (UnrollNum > 0 ? UnrollNum : 1);
+    static const bool ThreeBytes = (MaxBytes >= 3);
+
+    static FORCEINLINE bool ProcessSimple(const char *&inputPtr, const char *inputEnd, char *&outputPtr, bool isLastBlock) {
+        bool ok = true;
+        const EncoderLutEntry *RESTRICT ptrTable = EncoderLutTable<ThreeBytes>::GetArray();
+        while (inputPtr <= inputEnd - InputMinChunk) {
+            ok = EncoderCore<MaxBytes, Mode != dmFast, InputType>()(inputPtr, outputPtr, ptrTable);
+            if (!ok) {
+                if (Mode != dmFast)
+                    ok = EncodeTrivial<InputType>(inputPtr, inputPtr + InputMinChunk, outputPtr);
+                if (!ok) break;
+            }
+        }
+        if (isLastBlock)
+            ok = EncodeTrivial<InputType>(inputPtr, inputEnd, outputPtr);
+        return ok;
+    }
+
+public:
+
+    BufferEncoder() {
+        static_assert(MaxBytes >= 0 && MaxBytes <= 3, "MaxBytes must be between 0 and 3");
+        static_assert(InputType == 2 || InputType == 4, "InputType must be either 2 or 4");
+        static_assert(Mode >= 0 && Mode <= emAllCount, "Mode must be from EncoderMode enum");
+        static_assert(UnrollNum == 1 || UnrollNum == 4, "UnrollNum must be 1 or 4");
+        static_assert(MaxBytes > 0 || UnrollNum == 1, "UnrollNum must 1 when MaxBytes = 0");
+    }
+
+
+    virtual int GetStreamsCount() const {
+        return StreamsNumber;
+    }
+    virtual int GetInputBufferRecommendedSize() const {
+        return 1<<16;   //64KB
+    }
+    virtual long long GetOutputBufferMinSize(long long inputSize) const {
+        return (inputSize / InputType) * (InputType == 2 ? 3 : 4) + 16;
+    }
+
+    virtual bool _Process() {
+        TIMING_START(ENCODE);
+
+        const char *inputPtr = inputBuffer + inputDone;
+        char *outputPtr = outputBuffer[0] + outputDone[0];
+
+        if (UnrollNum == 4) {
+            const EncoderLutEntry *RESTRICT ptrTable = EncoderLutTable<ThreeBytes>::GetArray();
+            for (int i = 0; i < inputSize / InputUnrollChunk; i++) {
+                bool ok = 
+                    EncoderCore<MaxBytes, Mode != dmFast, InputType>()(inputPtr, outputPtr, ptrTable) &&
+                    EncoderCore<MaxBytes, Mode != dmFast, InputType>()(inputPtr, outputPtr, ptrTable) &&
+                    EncoderCore<MaxBytes, Mode != dmFast, InputType>()(inputPtr, outputPtr, ptrTable) &&
+                    EncoderCore<MaxBytes, Mode != dmFast, InputType>()(inputPtr, outputPtr, ptrTable);
+                if (!ok) break;
+            }
+        }
+
+        bool ok;
+        if (MaxBytes > 0)
+            ok = ProcessSimple(inputPtr, inputBuffer + inputSize, outputPtr, lastBlockMode);
+        else
+            ok = EncodeTrivial<InputType>(inputPtr, inputBuffer + inputSize, outputPtr);
+        inputDone = int(inputPtr - inputBuffer);
+        outputDone[0] = int(outputPtr - outputBuffer[0]);
+        if (!ok) return false;
+
+        TIMING_END(ENCODE, inputDone);
+        return true;
+    }
+};