react-native-quick-crypto 1.0.19 → 1.1.0

package/deps/simdutf/scripts/sse_validate_utf16le_proof.py

@@ -0,0 +1,137 @@
+# Note: Validation is done for 8-word input, we just need to check 3^8 = 6561 cases
+#       Validation for 16-word inputs requires 3**16 = 43'046'721 checks
+
+ELEMENTS_COUNT   = 8
+ALL_MASK         = (1 << ELEMENTS_COUNT) - 1
+ALL_BUT_ONE_MASK = (ALL_MASK >> 1)
+
+# 'V' - single-word character (always valid)
+# 'L' - low surrogate (must be followed by the high surrogate)
+# 'H' - high surrogate
+def all_sequences():
+    index = ['V'] * ELEMENTS_COUNT
+
+    def increment():
+        nonlocal index
+        for i in range(ELEMENTS_COUNT):
+            if index[i] == 'V':
+                index[i] = 'L'
+                return False
+
+            if index[i] == 'L':
+                index[i] = 'H'
+                return False
+
+            if index[i] == 'H':
+                index[i] = 'V' # wrap around
+                pass
+
+        return True
+
+    overflow = False
+    while not overflow:
+        yield index
+        overflow = increment()
+
+
+def find_error_in_words(words):
+    prev = None
+
+    if words[0] == 'H':
+        # We assume that our vector algorithm loads proper data into vectors.
+        # In the case low surrogate was the last item in the previous iteration.
+        return 'high surrogate must not start a chunk'
+
+    for i, kind in enumerate(words):
+        if kind == 'V':
+            if prev == 'L':
+                return f'low surrogate {i - 1} must be followed by high surrogate'
+        elif kind == 'L':
+            if prev == 'L':
+                return f'low surrogate {i - 1} must be followed by high surrogate'
+        elif kind == 'H':
+            if prev != 'L':
+                return f'high surrogate {i} must be preceded by low surrogate'
+
+        prev = kind
+
+    return ''
+
+
+def bitmask(words, state):
+    result = 0
+    for bit, type in enumerate(words):
+        if type == state:
+            # In SSE vector algorithm we compare 2 x 16 higher bytes of input
+            # words, which yields a 16-bit mask.
+            result |= 1 << bit
+
+    return result
+
+
+def mask(words):
+    L = bitmask(words, 'L')
+    H = bitmask(words, 'H')
+    V = (~(L | H)) & ALL_MASK
+
+    a = L & (H >> 1)
+    b = a << 1
+    c = V | a | b
+
+    return c
+
+
+def dump():
+    for words in all_sequences():
+
+        c = mask(words)
+
+        words_image = "[ %s ]" % ' | '.join(words)
+        error = find_error_in_words(words)
+        if error == '':
+            valid_image = 'T'
+        else:
+            valid_image = ' '
+
+        print(words_image, valid_image, '{:016b} {:04x}'.format(c, c))
+
+
+def proof():
+    case1_hit = False
+    case2_hit = False
+    for words in all_sequences():
+
+        c = mask(words)
+
+        if c == ALL_MASK:
+            case1_hit = True
+            # all 16 words are valid (either 'V' or pairs 'L', 'H')
+            assert find_error_in_words(words) == '', (words, find_error_in_words(words))
+
+        if c == ALL_BUT_ONE_MASK:
+            case2_hit = True
+            # all 15 words are valid (either 'V' or pairs 'L', 'H')
+            # the last words is either 'L' or 'H' (the word will be
+            # re-examined in the next iteration of an algorithm)
+            if words[-1] == 'H':
+                assert find_error_in_words(words) == 'high surrogate 7 must be preceded by low surrogate'
+            elif words[-1] == 'L':
+                assert find_error_in_words(words) == ''
+            else:
+                assert False
+
+    assert case1_hit
+    assert case2_hit
+
+    print("All OK")
+
+
+def main():
+    if 0:
+        dump()
+    else:
+        proof()
+
+
+if __name__ == '__main__':
+    main()

package/deps/simdutf/scripts/sse_validate_utf16le_testcases.py

@@ -0,0 +1,129 @@
+from itertools import product
+from random import randint, seed
+from sse_validate_utf16le_proof import bitmask
+
+
+# This is a copy from sse_validate_utf16le_proof.py with
+# adjusted the mask for the 16-bit base
+def mask(words):
+    L = bitmask(words, 'L')
+    H = bitmask(words, 'H')
+    V = (~(L | H)) & 0xffff
+
+    a = L & (H >> 1)
+    b = a << 1
+    c = V | a | b
+
+    return c
+
+
+class Record:
+    def __init__(self):
+        self.words = []
+
+
+    def add(self, word):
+        self.words.append(word)
+
+
+    @property
+    def is_valid(self):
+        c = mask(self.words)
+
+        if c == 0xffff:
+          return True
+
+        if c == 0x7fff:
+          # in test we reject cases when 'L' or 'H' ends a chunk
+          if self.words[-1] in ('L', 'H'):
+            return False
+          else:
+            return True
+
+        return False
+
+
+    def __str__(self):
+        words = ''.join(self.words)
+        if self.is_valid:
+            return 'T' + words
+        else:
+            return 'F' + words
+
+
+def test_words():
+    collection = set()
+    for seq in test_words_aux():
+        collection.add(tuple(seq))
+
+    return sorted(collection)
+
+
+def test_words_aux():
+    # 1. all valid
+    yield ['V'] * 16
+
+    # 2. only low surrogates
+    yield ['L'] * 16
+
+    # 3. only high surrogates
+    yield ['H'] * 16
+
+    # 4. sole low surrogate
+    for i in range(16):
+        seq = ['V'] * 16
+        seq[i] = 'L'
+        yield seq
+
+    # 5. sole high surrogate
+    for i in range(16):
+        seq = ['V'] * 16
+        seq[i] = 'H'
+        yield seq
+
+    # 6. scattered three surrogates
+    for i in range(16):
+        for j in range(16):
+            for k in range(16):
+                    seq = ['V'] * 16
+                    for a, b, c in product('LH', repeat=3):
+                        seq[i] = a
+                        seq[j] = b
+                        seq[k] = c
+                        yield seq
+
+    # To cover all 16-byte inputs we would need 3**16 cases (43'046'721)
+    # Instead, we cover all possible 6-element combinations (3**6 = 729)
+    # and move it within 16-element input. This yields 729 * 10 cases.
+    k = 6
+    for combination in product('VLH', repeat=k):
+        for position in range(16 - k):
+            seq = ['V'] * 16
+            for i, v in enumerate(combination):
+                seq[i + position] = v
+
+            yield seq
+
+
+TXT = """# generated by scripts/sse_validate_utf16le_testcases.py
+"""
+
+def write_file(file):
+    file.write(TXT)
+    for words in test_words():
+        record = Record()
+        for word in words:
+            record.add(word)
+
+        file.write(str(record))
+        file.write('\n')
+
+
+def main():
+    seed(0)
+    with open('validate_utf16_testcases.txt', 'w') as f:
+        write_file(f)
+
+
+if __name__ == '__main__':
+    main()

package/deps/simdutf/scripts/table.py

@@ -0,0 +1,207 @@
+class TableBase(object):
+    def __init__(self):
+        self.headers = []
+        self.rows    = []
+
+    def set_header(self, header):
+        assert len(header) > 0
+        self.headers = [self.normalize(header)]
+
+    def add_row(self, row):
+        assert len(row) > 0
+        self.rows.append(self.normalize(row))
+
+    def normalize(self, row):
+        tmp = []
+        for text, count in self.iter_spans(row):
+            assert count >= 1
+            if count == 1:
+                tmp.append(text)
+            else:
+                tmp.append((text, count))
+
+        return tmp
+
+    def is_raw(self, row):
+        return all(isinstance(val, str) for val in row)
+
+    def iter_spans(self, row):
+        for item in row:
+            if type(item) is tuple:
+                text  = item[0]
+                count = item[1]
+            else:
+                text  = item
+                count = 1
+
+            yield (text, count)
+
+
+class TableValidator(object):
+    def __init__(self, table):
+        self.table = table
+        self.columns = self.get_table_columns_count()
+        if self.columns is None:
+            raise ValueError("Table doesn't have header which define column layout")
+        self.validate()
+
+    def get_table_columns_count(self):
+        # only from headers
+        for header in self.table.headers:
+            if self.table.is_raw(header):
+                return len(header)
+
+    def validate(self):
+        for i, header in enumerate(self.table.headers):
+            n = self.get_columns_count(header)
+            if n != self.columns:
+                raise ValueError("header #%d has %d column(s), expected %d: %s" % (i, n, self.columns, header))
+
+        for i, row in enumerate(self.table.rows):
+            n = self.get_columns_count(row)
+            if n != self.columns:
+                raise ValueError("row #%d has %d column(s), expected %d: %s" % (i, n, self.columns, row))
+
+    def get_columns_count(self, row):
+        n = 0
+        for _, count in self.table.iter_spans(row):
+            n += count
+
+        return n
+
+
+ALIGN_RIGHT = '>'
+ALIGN_LEFT = '<'
+CENTER = '^'
+
+
+class MarkdownTableRenderer(object):
+    def __init__(self, table):
+        if len(table.headers) > 1:
+            raise ValueError("Markdown does not support multiple header rows")
+
+        self.validator  = TableValidator(table)
+        self.table      = table
+        self.padding    = 1
+        self.widths     = self._calculate_widths()
+
+    def get_headers(self):
+        return self.table.headers
+
+    def get_rows(self):
+        return self.table.rows
+
+    def _calculate_widths(self):
+        width = [0] * self.validator.columns
+
+        # get width from fixed
+        for row in self.get_headers() + self.get_rows():
+            index = 0
+            for text, count in self.table.iter_spans(row):
+                w = len(text)
+                width[index] = max(w, width[index])
+                index += 1
+
+        return width
+
+    def _get_columns_width(self, start, count):
+        assert count >= 1
+
+        w = 0
+        for index in range(start, start + count):
+            w += self.widths[index]
+            w += 2 * self.padding
+
+        w += (count - 1)  # for the columns spacing '|'
+        return w
+
+    def _render_separator(self, row, fill):
+        assert len(fill) == 1
+
+        result = '|'
+        index = 0
+        for text, count in self.table.iter_spans(row):
+            result += ' '
+            result += fill * (self._get_columns_width(index, count) - 2)
+            result += ' '
+            result += '|'
+            index  += count
+
+        return result
+
+    def _render_row(self, row, align=None):
+        if align is not None:
+            def get_align(text):
+                return align
+        else:
+            def get_align(text):
+                if is_float_or_int(text):
+                    return ALIGN_RIGHT
+                else:
+                    return ALIGN_LEFT
+
+        result = '|'
+        index = 0
+        for text, count in self.table.iter_spans(row):
+            width   = self._get_columns_width(index, count)
+            width  -= 2 * self.padding
+            result += ' ' * self.padding
+            result += u'{:{align}{width}}'.format(text, align=get_align(text), width=width)
+            result += ' ' * self.padding
+            result += '|'
+
+            index  += count
+
+        return result
+
+    def get_image(self):
+        lines = []
+
+        if self.table.headers:
+            header = self.table.headers[0]
+            lines.append(self._render_row(header, CENTER))
+            lines.append(self._render_separator(header, '-'))
+
+        for row in self.get_rows():
+            lines.append(self._render_row(row))
+
+        return '\n'.join(lines)
+
+
+class Table(TableBase):
+    def __unicode__(self):
+        renderer = MarkdownTableRenderer(self)
+        return renderer.get_image()
+
+    def __str__(self):
+        renderer = MarkdownTableRenderer(self)
+        return renderer.get_image()
+
+
+def is_float_or_int(text):
+    try:
+        float(text)
+        return True
+    except ValueError:
+        return False
+
+
+if __name__ == '__main__':
+
+    table = Table()
+
+    table.set_header(["procedure", "size", "time"])
+    table.add_row(["foo", "100", "0.5"])
+    table.add_row(["bar", "105", "1.5"])
+    table.add_row(["baz", "111", "0.2"])
+
+    print(table)
+
+    table2 = Table()
+    table2.set_header(["size1", "size2", "proc1", "proc2", "proc3"])
+    table2.add_row(["1", "2", "a", "b", "c"])
+    table2.add_row(["9", "3", "A", "B", "C"])
+    table2.add_row(["42", "-", ("N/A", 3)])
+
+    print()
+    print(table2)

package/deps/simdutf/scripts/tests/new.txt

@@ -0,0 +1,33 @@
+We define the number of bytes to be the number of *input* bytes.
+We define a 'char' to be a code point (between 1 and 4 bytes).
+===========================
+Using ICU version 72.1
+testcases: 4
+input detected as UTF16 little-endian
+current system detected as haswell
+===========================
+convert_utf32_to_latin1+haswell, input size: 328672, iterations: 30000, dataset: unicode_lipsum/wikipedia_mars/esperanto.utflatin32.txt
+   0.149 ins/byte,    0.051 cycle/byte,   88.806 GB/s (38.6 %),     4.504 GHz,    2.944 ins/cycle 
+   0.597 ins/char,    0.203 cycle/char,   22.202 Gc/s (38.6 %)     4.00 byte/char   3701.0 ns
+WARNING: Measurements are noisy, try increasing iteration count (-I).
+input detected as UTF16 little-endian
+current system detected as haswell
+===========================
+convert_utf32_to_latin1+haswell, input size: 1729220, iterations: 30000, dataset: unicode_lipsum/wikipedia_mars/french.utflatin32.txt
+   0.149 ins/byte,    0.048 cycle/byte,   92.388 GB/s (43.9 %),     4.430 GHz,    3.099 ins/cycle 
+   0.594 ins/char,    0.192 cycle/char,   23.097 Gc/s (43.9 %)     4.00 byte/char  18717.0 ns
+WARNING: Measurements are noisy, try increasing iteration count (-I).
+input detected as UTF16 little-endian
+current system detected as haswell
+===========================
+convert_utf32_to_latin1+haswell, input size: 797324, iterations: 30000, dataset: unicode_lipsum/wikipedia_mars/german.utflatin32.txt
+   0.149 ins/byte,    0.050 cycle/byte,   79.836 GB/s (49.2 %),     4.020 GHz,    2.953 ins/cycle 
+   0.595 ins/char,    0.201 cycle/char,   19.959 Gc/s (49.2 %)     4.00 byte/char   9987.0 ns
+WARNING: Measurements are noisy, try increasing iteration count (-I).
+input detected as UTF16 little-endian
+current system detected as haswell
+===========================
+convert_utf32_to_latin1+haswell, input size: 1086972, iterations: 30000, dataset: unicode_lipsum/wikipedia_mars/portuguese.utflatin32.txt
+   0.149 ins/byte,    0.049 cycle/byte,   92.642 GB/s (17.6 %),     4.569 GHz,    3.016 ins/cycle 
+   0.595 ins/char,    0.197 cycle/char,   23.161 Gc/s (17.6 %)     4.00 byte/char  11733.0 ns
+WARNING: Measurements are noisy, try increasing iteration count (-I).

package/deps/simdutf/scripts/tests/old.txt

@@ -0,0 +1,33 @@
+We define the number of bytes to be the number of *input* bytes.
+We define a 'char' to be a code point (between 1 and 4 bytes).
+===========================
+Using ICU version 72.1
+testcases: 4
+input detected as UTF16 little-endian
+current system detected as haswell
+===========================
+convert_utf32_to_latin1+haswell, input size: 328672, iterations: 30000, dataset: ./unicode_lipsum/wikipedia_mars/esperanto.utflatin32.txt
+   0.251 ins/byte,    0.062 cycle/byte,   77.135 GB/s (42.3 %),     4.798 GHz,    4.033 ins/cycle 
+   1.004 ins/char,    0.249 cycle/char,   19.284 Gc/s (42.3 %)     4.00 byte/char   4261.0 ns
+WARNING: Measurements are noisy, try increasing iteration count (-I).
+input detected as UTF16 little-endian
+current system detected as haswell
+===========================
+convert_utf32_to_latin1+haswell, input size: 1729220, iterations: 30000, dataset: ./unicode_lipsum/wikipedia_mars/french.utflatin32.txt
+   0.250 ins/byte,    0.058 cycle/byte,   75.259 GB/s (40.1 %),     4.399 GHz,    4.279 ins/cycle 
+   1.001 ins/char,    0.234 cycle/char,   18.815 Gc/s (40.1 %)     4.00 byte/char  22977.0 ns
+WARNING: Measurements are noisy, try increasing iteration count (-I).
+input detected as UTF16 little-endian
+current system detected as haswell
+===========================
+convert_utf32_to_latin1+haswell, input size: 797324, iterations: 30000, dataset: ./unicode_lipsum/wikipedia_mars/german.utflatin32.txt
+   0.250 ins/byte,    0.060 cycle/byte,   76.110 GB/s (37.5 %),     4.585 GHz,    4.155 ins/cycle 
+   1.001 ins/char,    0.241 cycle/char,   19.027 Gc/s (37.5 %)     4.00 byte/char  10476.0 ns
+WARNING: Measurements are noisy, try increasing iteration count (-I).
+input detected as UTF16 little-endian
+current system detected as haswell
+===========================
+convert_utf32_to_latin1+haswell, input size: 1086972, iterations: 30000, dataset: ./unicode_lipsum/wikipedia_mars/portuguese.utflatin32.txt
+   0.250 ins/byte,    0.060 cycle/byte,   84.124 GB/s (56.8 %),     5.040 GHz,    4.177 ins/cycle 
+   1.001 ins/char,    0.240 cycle/char,   21.031 Gc/s (56.8 %)     4.00 byte/char  12921.0 ns
+WARNING: Measurements are noisy, try increasing iteration count (-I).