CRC64 Jones polynomial with improvements

CMakeLists.txt

@@ -717,6 +717,9 @@ add_library(
   ${UMASH_SRC}
   ${KHASHV_SRC}
   xmsx.c
+  crc64.c
+  crcspeed.c
+  crccombine.c
   )
 
 add_executable(SMHasher main.cpp)

Hashes.h

@@ -1374,3 +1374,16 @@ void khashv64_test ( const void *key, int len, uint32_t seed, void *out);
 extern PolymurHashParams g_polymurhashparams;
 void polymur_seed_init (size_t &seed);
 void polymur_test ( const void *key, int len, uint32_t seed, void *out);
+
+
+/* This version of CRC64 can approach HW crc speeds without hardware support,
+   and can be applied to any polynomial. */
+#include "crc64.h"
+#include "crcspeed.h"
+#include "crccombine.h"
+
+extern "C" void crc64_jones_test1(const void *input, int len, uint32_t seed, void *out);
+extern "C" void crc64_jones_test2(const void *input, int len, uint32_t seed, void *out);
+extern "C" void crc64_jones_test3(const void *input, int len, uint32_t seed, void *out);
+extern "C" void crc64_jones_default(const void *input, int len, uint32_t seed, void *out);
+

crc64.c

@@ -0,0 +1,175 @@
+/* Copyright (c) 2014, Matt Stancliff <[email protected]>
+ * Copyright (c) 2020, Amazon Web Services
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the name of Redis nor the names of its contributors may be used
+ *     to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE. */
+
+#include "crc64.h"
+#include "crcspeed.h"
+static uint64_t crc64_table[8][256] = {{0}};
+
+#define POLY UINT64_C(0xad93d23594c935a9)
+/******************** BEGIN GENERATED PYCRC FUNCTIONS ********************/
+/**
+ * Generated on Sun Dec 21 14:14:07 2014,
+ * by pycrc v0.8.2, https://www.tty1.net/pycrc/
+ *
+ * LICENSE ON GENERATED CODE:
+ * ==========================
+ * As of version 0.6, pycrc is released under the terms of the MIT licence.
+ * The code generated by pycrc is not considered a substantial portion of the
+ * software, therefore the author of pycrc will not claim any copyright on
+ * the generated code.
+ * ==========================
+ *
+ * CRC configuration:
+ *    Width        = 64
+ *    Poly         = 0xad93d23594c935a9
+ *    XorIn        = 0xffffffffffffffff
+ *    ReflectIn    = True
+ *    XorOut       = 0x0000000000000000
+ *    ReflectOut   = True
+ *    Algorithm    = bit-by-bit-fast
+ *
+ * Modifications after generation (by matt):
+ *   - included finalize step in-line with update for single-call generation
+ *   - re-worked some inner variable architectures
+ *   - adjusted function parameters to match expected prototypes.
+ *****************************************************************************/
+
+/**
+ * Reflect all bits of a \a data word of \a data_len bytes.
+ *
+ * \param data         The data word to be reflected.
+ * \param data_len     The width of \a data expressed in number of bits.
+ * \return             The reflected data.
+ *****************************************************************************/
+static inline uint_fast64_t crc_reflect(uint_fast64_t data, size_t data_len) {
+    /* only ever called for data_len == 64 in this codebase
+     *
+     * Borrowed from bit twiddling hacks, original in the public domain.
+     * https://graphics.stanford.edu/~seander/bithacks.html#ReverseParallel
+     * Extended to 64 bits, and added byteswap for final 3 steps.
+     * 16-30x 64-bit operations, no comparisons (16 for native byteswap, 30 for pure C)
+     */
+
+    /* swap odd and even bits */
+    data = ((data >> 1) & 0x5555555555555555ULL) | ((data & 0x5555555555555555ULL) << 1);
+    /* swap consecutive pairs */
+    data = ((data >> 2) & 0x3333333333333333ULL) | ((data & 0x3333333333333333ULL) << 2);
+    /* swap nibbles ... */
+    data = ((data >> 4) & 0x0F0F0F0F0F0F0F0FULL) | ((data & 0x0F0F0F0F0F0F0F0FULL) << 4);
+#if defined(__GNUC__) || defined(__clang__)
+    data = __builtin_bswap64(data);
+#else
+    /* swap bytes */
+    data = ((data >> 8) & 0x00FF00FF00FF00FFULL) | ((data & 0x00FF00FF00FF00FFULL) << 8);
+    /* swap 2-byte long pairs */
+    data = ( data >> 16 &     0xFFFF0000FFFFULL) | ((data &     0xFFFF0000FFFFULL) << 16);
+    /* swap 4-byte quads */
+    data = ( data >> 32 &         0xFFFFFFFFULL) | ((data &         0xFFFFFFFFULL) << 32);
+#endif
+    /* adjust for non-64-bit reversals */
+    return data >> (64 - data_len);
+}
+
+/**
+ *  Update the crc value with new data.
+ *
+ * \param crc      The current crc value.
+ * \param data     Pointer to a buffer of \a data_len bytes.
+ * \param data_len Number of bytes in the \a data buffer.
+ * \return         The updated crc value.
+ ******************************************************************************/
+uint64_t _crc64(uint_fast64_t crc, const void *in_data, const uint64_t len) {
+    const uint8_t *data = in_data;
+    unsigned long long bit;
+
+    for (uint64_t offset = 0; offset < len; offset++) {
+        uint8_t c = data[offset];
+        for (uint_fast8_t i = 0x01; i & 0xff; i <<= 1) {
+            bit = crc & 0x8000000000000000;
+            if (c & i) {
+                bit = !bit;
+            }
+
+            crc <<= 1;
+            if (bit) {
+                crc ^= POLY;
+            }
+        }
+
+        crc &= 0xffffffffffffffff;
+    }
+
+    crc = crc & 0xffffffffffffffff;
+    return crc_reflect(crc, 64) ^ 0x0000000000000000;
+}
+
+/******************** END GENERATED PYCRC FUNCTIONS ********************/
+
+/* Initializes the 16KB lookup tables. */
+void crc64_init(void) {
+    crcspeed64native_init(_crc64, crc64_table);
+}
+
+/* Compute crc64 */
+uint64_t crc64(uint64_t crc, const unsigned char *s, uint64_t l) {
+    return crcspeed64native(crc64_table, crc, (void *) s, l);
+}
+
+
+void crc64_jones_test1(const void *input, int len, uint32_t seed, void *out)
+{
+    if (!crc64_table[0][1]) crc64_init();
+    size_t old1 = get_cutoff(0), old2 = get_cutoff(1);
+    set_crc64_cutoffs(SIZE_MAX, SIZE_MAX);
+    ((uint64_t*)out)[0] = crc64((uint64_t)seed, (const unsigned char*)input, len);
+    set_crc64_cutoffs(old2, old1);
+}
+
+void crc64_jones_test2(const void *input, int len, uint32_t seed, void *out)
+{
+    if (!crc64_table[0][1]) crc64_init();
+    size_t old1 = get_cutoff(0), old2 = get_cutoff(1);
+    set_crc64_cutoffs(1, SIZE_MAX);
+    ((uint64_t*)out)[0] = crc64((uint64_t)seed, (const unsigned char*)input, len);
+    set_crc64_cutoffs(old2, old1);
+}
+
+void crc64_jones_test3(const void *input, int len, uint32_t seed, void *out)
+{
+    if (!crc64_table[0][1]) crc64_init();
+    size_t old1 = get_cutoff(0), old2 = get_cutoff(1);
+    set_crc64_cutoffs(1, 1);
+    ((uint64_t*)out)[0] = crc64((uint64_t)seed, (const unsigned char*)input, len);
+    set_crc64_cutoffs(old2, old1);
+}
+
+void crc64_jones_default(const void *input, int len, uint32_t seed, void *out)
+{
+    if (!crc64_table[0][1]) crc64_init();
+    ((uint64_t*)out)[0] = crc64((uint64_t)seed, (const unsigned char*)input, len);
+}

crc64.h

@@ -0,0 +1,10 @@
+#ifndef CRC64_H
+#define CRC64_H
+
+#include <stdint.h>
+
+void crc64_init(void);
+uint64_t crc64(uint64_t crc, const unsigned char *s, uint64_t l);
+
+
+#endif