crc-turbo 0.1 → 0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 042e9756847215414abcb1a12fbf37b81d7fe16f
-  data.tar.gz: aac8893c3843eaf1055db3ace8a2623b35be3f3c
+  metadata.gz: a9c55e6cae87bb11776ca21753515a6c5f9d5d93
+  data.tar.gz: a57614ca5264bae1ad92edd823ece6a4e530885d
 SHA512:
-  metadata.gz: a62d436e87a9d0fae480d3e69247017a55e1abe300f828aa3b9b3c38702cdc01c9afa4d22d1f72d56ebc0030f7cf47c9bbd2d81dbdeb1570d16c194d06d17bd9
-  data.tar.gz: 07b0ad0a958e8c243d514c677b24a8a1c54fd1b9548900b507a06d9565cd35a14380eb6aa02382e9d4ee67f7598abe9ac776d0e0b8892e82ce135128b9d8dfa8
+  metadata.gz: 39813537987919956767a2ecef0ae83e055c9a2adb7c41b540030f45fa9b5d309bf244fcb95d5f82c74dce71241fbd7b9cdd7ae76340d4322abc28e7fe5b9421
+  data.tar.gz: 180d142c3f0df7a350e1493421f0b11af33b8d79be1f2b8cdac035226e3ed1e8c2f443400a3e195c4d9548b481e86f8605b37707845fa65dddc675205163ff02

data/HISTORY.ja.md

@@ -0,0 +1,14 @@
+This document is written in Japanese.
+
+# crc-turbo for ruby の更新履歴
+
+## crc-0.2 (平成28年5月15日 (日))
+
+  * \[FIX\] CRC::Generator#polynomial メソッドが間違った値を返していた問題を修正
+  * CRC::Utils.bitreflect128 メソッドの実装
+  * CRC::BasicCRC#update メソッドの実装を slice-by-eight から slice-by-16 へと変更
+  * CRC ルックアップテーブル領域確保の時機を初回計算時の直前とするように改善
+
+## crc-0.1 (平成28年5月8日 (日))
+
+初版

data/README.md

@@ -3,24 +3,24 @@
 
 This is a C extention for "crc" gem library.
 
-Just install this, and "require 'crc'". Additional other work is not required.
+Just install this, and to do "require 'crc'" only. Additional other work is not required.
 
 
-## SUMMARY
+## Summary
 
   * package name: crc-turbo
   * author: dearblue (mailto:dearblue@users.osdn.me)
   * report issue to: <https://osdn.jp/projects/rutsubo/ticket/>
   * how to install: ``gem install crc-turbo``
-  * version: 0.1
+  * version: 0.2
   * release quality: thechnical preview
-  * licensing: BSD-2-Clause
-  * dependency gems: crc (<https://rubygems/gems/crc>)
+  * licensing: BSD-2-Clause<br>any parts are under Creative Commons License Zero (CC0 / Public Domain).
+  * dependency gems: crc-0.2 (<https://rubygems/gems/crc>)
   * dependency external c libraries: none
   * bundled external c libraries: none
 
 
-## HOW TO USAGE
+## How to usage
 
 First, install on your system.
 
@@ -34,19 +34,21 @@ And, to do ``require "crc"``.
 
 ``` shell:shell
 $ ruby -r crc -e 'puts $".grep(/crc/)'
-/usr/local/lib/ruby/gems/2.3/gems/crc-turbo-0.1/lib/crc/_turbo.so
-/usr/local/lib/ruby/gems/2.3/gems/crc-0.1/lib/crc/_modules.rb
-/usr/local/lib/ruby/gems/2.3/gems/crc-0.1/lib/crc.rb
+/usr/local/lib/ruby/gems/2.3/gems/crc-turbo-0.2/lib/crc/2.3/_turbo.so
+/usr/local/lib/ruby/gems/2.3/gems/crc-0.2/lib/crc/_modules.rb
+/usr/local/lib/ruby/gems/2.3/gems/crc-0.2/lib/crc/_combine.rb
+/usr/local/lib/ruby/gems/2.3/gems/crc-0.2/lib/crc.rb
 $
 ```
 
-If you want not use crc-turbo, set ``RUBY_CRC_NOFAST`` enviroment variable.
+If you want to not use crc-turbo, set ``RUBY_CRC_NOFAST`` enviroment variable.
 
 ``` shell:shell
-$ RUBY_CRC_NOFAST=1
+$ export RUBY_CRC_NOFAST=1
 $ ruby -r crc -e 'puts $".grep(/crc/)'
-/usr/local/lib/ruby/gems/2.3/gems/crc-0.1/lib/crc/_byruby.rb
-/usr/local/lib/ruby/gems/2.3/gems/crc-0.1/lib/crc/_modules.rb
-/usr/local/lib/ruby/gems/2.3/gems/crc-0.1/lib/crc.rb
+/usr/local/lib/ruby/gems/2.3/gems/crc-0.2/lib/crc/_byruby.rb
+/usr/local/lib/ruby/gems/2.3/gems/crc-0.2/lib/crc/_modules.rb
+/usr/local/lib/ruby/gems/2.3/gems/crc-0.2/lib/crc/_combine.rb
+/usr/local/lib/ruby/gems/2.3/gems/crc-0.2/lib/crc.rb
 $
 ```

data/ext/crc/crc_imps.h

@@ -0,0 +1,264 @@
+/*
+ * author:: dearblue <dearblue@users.osdn.me>
+ * license:: Creative Commons License Zero (CC0 / Public Domain)
+ *
+ * This is a general CRC generator.
+ *
+ * It's used slice-by-16 algorithm with byte-order free and byte-alignment free.
+ * This is based on the Intel's slice-by-eight algorithm.
+ *
+ * Worst point is need more memory!
+ *
+ * reference:
+ * * https://sourceforge.net/projects/slicing-by-8/
+ * * xz-utils
+ *      * http://tukaani.org/xz/
+ *      * xz-5.2.2/src/liblzma/check/crc32_fast.c
+ *      * xz-5.2.2/src/liblzma/check/crc32_tablegen.c
+ */
+
+#if     !defined(CRC_TYPE) || \
+        !defined(CRC_BITREFLECT) || \
+        !defined(CRC_BUILD_TABLES) || \
+        !defined(CRC_UPDATE) || \
+        !defined(CRC_BUILD_REFLECT_TABLES) || \
+        !defined(CRC_REFLECT_UPDATE)
+#   error not defined CRC_TYPE, CRC_BITREFLECT, CRC_BUILD_TABLES, CRC_UPDATE, CRC_BUILD_REFLECT_TABLES or CRC_REFLECT_UPDATE before include this file
+#endif
+
+#ifndef CRC_INLINE
+#   define CRC_INLINE
+#endif
+
+/*
+ * [bitsize]
+ *      CRC bit-size. 32 for CRC-32, 7 for CRC-7, and so on.
+ *
+ * [table]
+ *      lookup table. total byte size is sizeof(CRC_TYPE[slicesize][256]).
+ *
+ *      16384 for CRC-32:slicesize=16.
+ *
+ * [poly]
+ *      polynomial. not reflected.
+ *
+ * [slicesize]
+ *      table slice size.
+ *
+ *      1 for standard lookup-table, 4 for slice-by-four, 16 for slice-by-16, and so on.
+ */
+static CRC_INLINE void
+CRC_BUILD_TABLES(int bitsize, CRC_TYPE table[][256], CRC_TYPE poly, int slicesize)
+{
+    static const int typebits = sizeof(CRC_TYPE) * CHAR_BIT;
+    CRC_TYPE (*t)[256] = table;
+    int s, b, i;
+    poly <<= (typebits - bitsize);
+    for (s = 0; s < slicesize; s ++) {
+        CRC_TYPE *p = *t;
+        for (b = 0; b < 256; b ++) {
+            CRC_TYPE r = (s == 0) ? ((CRC_TYPE)b << (typebits - 8)) : t[-1][b];
+            for (i = 0; i < 8; i ++) {
+                r = (r << 1) ^ (poly & -(r >> (typebits - 1)));
+            }
+            *p ++ = r;
+        }
+        t ++;
+    }
+}
+
+/*
+ * [bitsize]
+ *      CRC bit-size. 32 for CRC-32, 7 for CRC-7, and so on.
+ *
+ * [table]
+ *      lookup table. total byte size is sizeof(CRC_TYPE[slicesize][256]).
+ *
+ *      16384 for CRC-32:slicesize=16.
+ *
+ * [poly]
+ *      polynomial. not reflected.
+ *
+ * [slicesize]
+ *      table slice size.
+ *
+ *      1 for standard lookup-table, 4 for slice-by-four, 16 for slice-by-16, and so on.
+ */
+static CRC_INLINE void
+CRC_BUILD_REFLECT_TABLES(int bitsize, CRC_TYPE table[][256], CRC_TYPE poly, int slicesize)
+{
+    static const int typebits = sizeof(CRC_TYPE) * CHAR_BIT;
+    CRC_TYPE (*t)[256] = table;
+    poly = CRC_BITREFLECT(poly << (typebits - bitsize));
+    int s, b;
+    for (s = 0; s < slicesize; s ++) {
+        CRC_TYPE *p = *t;
+        for (b = 0; b < 256; b ++) {
+            int i;
+            CRC_TYPE r = (s == 0) ? b : t[-1][b];
+            for (i = 0; i < 8; i ++) {
+                r = (r >> 1) ^ (poly & -(r & 1));
+            }
+            *p ++ = r;
+        }
+        t ++;
+    }
+}
+
+static CRC_TYPE
+CRC_UPDATE(int bitsize, const CRC_TYPE table[16][256],
+        const char *p, const char *pp, CRC_TYPE state)
+{
+    static const int typebits = sizeof(CRC_TYPE) * CHAR_BIT;
+    const char *pp16 = ((pp - p) & ~0x0f) + p;
+    state <<= typebits - bitsize;
+    for (; p < pp16; p += 16) {
+        state = table[15][(uint8_t)p[ 0] ^                   (uint8_t)(state >> (typebits -   8))     ] ^
+                table[14][(uint8_t)p[ 1] ^ (typebits >   8 ? (uint8_t)(state >> (typebits -  16)) : 0)] ^
+                table[13][(uint8_t)p[ 2] ^ (typebits >  16 ? (uint8_t)(state >> (typebits -  24)) : 0)] ^
+                table[12][(uint8_t)p[ 3] ^ (typebits >  24 ? (uint8_t)(state >> (typebits -  32)) : 0)] ^
+                table[11][(uint8_t)p[ 4] ^ (typebits >  32 ? (uint8_t)(state >> (typebits -  40)) : 0)] ^
+                table[10][(uint8_t)p[ 5] ^ (typebits >  40 ? (uint8_t)(state >> (typebits -  48)) : 0)] ^
+                table[ 9][(uint8_t)p[ 6] ^ (typebits >  48 ? (uint8_t)(state >> (typebits -  56)) : 0)] ^
+                table[ 8][(uint8_t)p[ 7] ^ (typebits >  56 ? (uint8_t)(state >> (typebits -  64)) : 0)] ^
+                table[ 7][(uint8_t)p[ 8] ^ (typebits >  64 ? (uint8_t)(state >> (typebits -  72)) : 0)] ^
+                table[ 6][(uint8_t)p[ 9] ^ (typebits >  72 ? (uint8_t)(state >> (typebits -  80)) : 0)] ^
+                table[ 5][(uint8_t)p[10] ^ (typebits >  80 ? (uint8_t)(state >> (typebits -  88)) : 0)] ^
+                table[ 4][(uint8_t)p[11] ^ (typebits >  88 ? (uint8_t)(state >> (typebits -  96)) : 0)] ^
+                table[ 3][(uint8_t)p[12] ^ (typebits >  96 ? (uint8_t)(state >> (typebits - 104)) : 0)] ^
+                table[ 2][(uint8_t)p[13] ^ (typebits > 104 ? (uint8_t)(state >> (typebits - 112)) : 0)] ^
+                table[ 1][(uint8_t)p[14] ^ (typebits > 112 ? (uint8_t)(state >> (typebits - 120)) : 0)] ^
+                table[ 0][(uint8_t)p[15] ^ (typebits > 120 ? (uint8_t)(state >> (typebits - 128)) : 0)];
+    }
+
+    static const int sh = typebits - 8;
+    for (; p < pp; p ++) {
+        state = table[0][(uint8_t)*p ^ (uint8_t)(state >> sh)] ^ (state << 8);
+    }
+
+    return state >> (typebits - bitsize);
+}
+
+/*
+ * [bitsize]
+ *      CRC bit-size. 32 for CRC-32, 7 for CRC-7, and so on.
+ *
+ * [table]
+ *      lookup table.
+ *
+ * [p]
+ *      input sequence.
+ *
+ * [pp]
+ *      end of input sequence.
+ *
+ *      example, p + len(p).
+ *
+ * [state]
+ *      internal state.
+ *
+ *      example, state ^ xor_output.
+ */
+static CRC_INLINE CRC_TYPE
+CRC_REFLECT_UPDATE(int bitsize, const CRC_TYPE table[16][256],
+        const char *p, const char *pp, CRC_TYPE state)
+{
+    static const int typebits = sizeof(CRC_TYPE) * CHAR_BIT;
+    const char *pp16 = ((pp - p) & ~0x0f) + p;
+    for (; p < pp16; p += 16) {
+        state = table[15][(uint8_t)p[ 0] ^                   (uint8_t)(state >>   0)     ] ^
+                table[14][(uint8_t)p[ 1] ^ (typebits >   8 ? (uint8_t)(state >>   8) : 0)] ^
+                table[13][(uint8_t)p[ 2] ^ (typebits >  16 ? (uint8_t)(state >>  16) : 0)] ^
+                table[12][(uint8_t)p[ 3] ^ (typebits >  24 ? (uint8_t)(state >>  24) : 0)] ^
+                table[11][(uint8_t)p[ 4] ^ (typebits >  32 ? (uint8_t)(state >>  32) : 0)] ^
+                table[10][(uint8_t)p[ 5] ^ (typebits >  40 ? (uint8_t)(state >>  40) : 0)] ^
+                table[ 9][(uint8_t)p[ 6] ^ (typebits >  48 ? (uint8_t)(state >>  48) : 0)] ^
+                table[ 8][(uint8_t)p[ 7] ^ (typebits >  56 ? (uint8_t)(state >>  56) : 0)] ^
+                table[ 7][(uint8_t)p[ 8] ^ (typebits >  64 ? (uint8_t)(state >>  64) : 0)] ^
+                table[ 6][(uint8_t)p[ 9] ^ (typebits >  72 ? (uint8_t)(state >>  72) : 0)] ^
+                table[ 5][(uint8_t)p[10] ^ (typebits >  80 ? (uint8_t)(state >>  80) : 0)] ^
+                table[ 4][(uint8_t)p[11] ^ (typebits >  88 ? (uint8_t)(state >>  88) : 0)] ^
+                table[ 3][(uint8_t)p[12] ^ (typebits >  96 ? (uint8_t)(state >>  96) : 0)] ^
+                table[ 2][(uint8_t)p[13] ^ (typebits > 104 ? (uint8_t)(state >> 104) : 0)] ^
+                table[ 1][(uint8_t)p[14] ^ (typebits > 112 ? (uint8_t)(state >> 112) : 0)] ^
+                table[ 0][(uint8_t)p[15] ^ (typebits > 120 ? (uint8_t)(state >> 120) : 0)];
+    }
+
+    for (; p < pp; p ++) {
+        state = table[0][(uint8_t)*p ^ (uint8_t)state] ^ (state >> 8);
+    }
+
+    return state;
+}
+
+#ifdef CRC_REFLECT_UPDATE_WITH_BITWISE
+
+/*
+ * no lookup tables with bitwise.
+ *
+ * reference::
+ *      http://www.hackersdelight.org/hdcodetxt/crc.c.txt#crc32b
+ */
+static CRC_INLINE CRC_TYPE
+CRC_REFLECT_UPDATE_WITH_BITWISE(const int bitsize, CRC_TYPE poly,
+        const char *p, const char *pp, CRC_TYPE state)
+{
+    poly = CRC_BITREFLECT(poly) >> (32 - bitsize);
+
+    for (; p < pp; p ++) {
+        state ^= (uint8_t)*p;
+        int i;
+        for (i = 0; i < 8; i ++) {
+            state = (state >> 1) ^ (poly & -(state & 1));
+        }
+    }
+
+    return state;
+}
+
+#undef CRC_REFLECT_UPDATE_WITH_BITWISE
+#endif
+
+#ifdef CRC_REFLECT_UPDATE_WITH_BITPACK
+
+/*
+ * loopless for each bits.
+ *
+ * reference::
+ *      http://www.hackersdelight.org/hdcodetxt/crc.c.txt#crc32h
+ */
+static CRC_INLINE CRC_TYPE
+CRC_REFLECT_UPDATE_WITH_BITPACK(const int bitsize, const CRC_TYPE poly,
+        const char *p, const char *pp, CRC_TYPE state)
+{
+    const CRC_TYPE g0 = CRC_BITREFLECT(poly) >> (32 - bitsize),
+                   g1 = (g0 >> 1) ^ (g0 & -(g0 & 1)),
+                   g2 = (g1 >> 1) ^ (g0 & -(g1 & 1)),
+                   g3 = (g2 >> 1) ^ (g0 & -(g2 & 1)),
+                   g4 = (g3 >> 1) ^ (g0 & -(g3 & 1)),
+                   g5 = (g4 >> 1) ^ (g0 & -(g4 & 1)),
+                   g6 = (g5 >> 1) ^ (g0 & -(g5 & 1)),
+                   g7 = (g6 >> 1) ^ (g0 & -(g6 & 1));
+
+    for (; p < pp; p ++) {
+        const uint8_t s1 = state ^ *p;
+        state = (g7 & -(CRC_TYPE)((s1 >> 0) & 1)) ^ (g6 & -(CRC_TYPE)((s1 >> 1) & 1)) ^
+                (g5 & -(CRC_TYPE)((s1 >> 2) & 1)) ^ (g4 & -(CRC_TYPE)((s1 >> 3) & 1)) ^
+                (g3 & -(CRC_TYPE)((s1 >> 4) & 1)) ^ (g2 & -(CRC_TYPE)((s1 >> 5) & 1)) ^
+                (g1 & -(CRC_TYPE)((s1 >> 6) & 1)) ^ (g0 & -(CRC_TYPE)((s1 >> 7) & 1)) ^
+                (state >> 8);
+    }
+
+    return state;
+}
+
+#undef CRC_REFLECT_UPDATE_WITH_BITPACK
+#endif
+
+#undef CRC_TYPE
+#undef CRC_BITREFLECT
+#undef CRC_BUILD_TABLES
+#undef CRC_UPDATE
+#undef CRC_BUILD_REFLECT_TABLES
+#undef CRC_REFLECT_UPDATE
+#undef CRC_INLINE

data/ext/crc/crcturbo.c

@@ -228,6 +228,19 @@ bitreflect128(uint128_t n)
 }
 #endif
 
+static inline unsigned long
+bitreflect_ulong(unsigned long n)
+{
+    if (sizeof(unsigned long) == sizeof(uint64_t)) {
+        return bitreflect64(n);
+    } else if (sizeof(unsigned long) == sizeof(uint32_t)) {
+        return bitreflect32(n);
+    } else {
+        // FIXME
+        return ~0;
+    }
+}
+
 static inline int
 bitsize_to_type(int bitsize)
 {
@@ -246,131 +259,48 @@ bitsize_to_type(int bitsize)
     }
 }
 
+#define CRC_TYPE                    uint8_t
+#define CRC_BITREFLECT              bitreflect8
+#define CRC_BUILD_TABLES            crc_build_tables_u8
+#define CRC_UPDATE                  crc_update_u8
+#define CRC_BUILD_REFLECT_TABLES    crc_build_reflect_tables_u8
+#define CRC_REFLECT_UPDATE          crc_reflect_update_u8
+#include "crc_imps.h"
+
+#define CRC_TYPE                    uint16_t
+#define CRC_BITREFLECT              bitreflect16
+#define CRC_BUILD_TABLES            crc_build_tables_u16
+#define CRC_UPDATE                  crc_update_u16
+#define CRC_BUILD_REFLECT_TABLES    crc_build_reflect_tables_u16
+#define CRC_REFLECT_UPDATE          crc_reflect_update_u16
+#include "crc_imps.h"
+
+#define CRC_TYPE                    uint32_t
+#define CRC_BITREFLECT              bitreflect32
+#define CRC_BUILD_TABLES            crc_build_tables_u32
+#define CRC_UPDATE                  crc_update_u32
+#define CRC_BUILD_REFLECT_TABLES    crc_build_reflect_tables_u32
+#define CRC_REFLECT_UPDATE          crc_reflect_update_u32
+#include "crc_imps.h"
+
+#define CRC_TYPE                    uint64_t
+#define CRC_BITREFLECT              bitreflect64
+#define CRC_BUILD_TABLES            crc_build_tables_u64
+#define CRC_UPDATE                  crc_update_u64
+#define CRC_BUILD_REFLECT_TABLES    crc_build_reflect_tables_u64
+#define CRC_REFLECT_UPDATE          crc_reflect_update_u64
+#include "crc_imps.h"
 
-#define IMP_BUILD_TABLE(NAME, TYPE)                                         \
-    static void                                                             \
-    NAME(TYPE table[8][256], int bitsize, TYPE poly)                        \
-    {                                                                       \
-        static const int typesize = sizeof(TYPE) * CHAR_BIT;                \
-        poly <<= (typesize - bitsize);                                      \
-        TYPE (*t)[256] = table;                                             \
-        int s, b, i;                                                        \
-        for (s = 0; s < 8; s ++) {                                          \
-            TYPE *p = *t;                                                   \
-            for (b = 0; b < 256; b ++) {                                    \
-                TYPE r = (s == 0) ? ((TYPE)b << (typesize - 8)) : t[-1][b]; \
-                for (i = 0; i < 8; i ++) {                                  \
-                    r = (r << 1) ^ (poly & -(r >> (typesize - 1)));         \
-                }                                                           \
-                *p ++ = r;                                                  \
-            }                                                               \
-            t ++;                                                           \
-        }                                                                   \
-    }                                                               
-
-#define IMP_CRC_UPDATE(NAME, TYPE)                                                                        \
-    static TYPE                                                                                           \
-    NAME(int bitsize, const TYPE table[8][256],                                                           \
-            const char *p, const char *pp, TYPE state)                                                    \
-    {                                                                                                     \
-        static const int typesize = sizeof(TYPE) * CHAR_BIT;                                              \
-        const char *pp8 = ((pp - p) & ~0x07) + p;                                                         \
-        state <<= typesize - bitsize;                                                                     \
-        for (; p < pp8; p += 8) {                                                                         \
-            state = table[7][(uint8_t)p[0] ^                  (uint8_t)(state >> (typesize -  8))     ] ^ \
-                    table[6][(uint8_t)p[1] ^ (typesize >  8 ? (uint8_t)(state >> (typesize - 16)) : 0)] ^ \
-                    table[5][(uint8_t)p[2] ^ (typesize > 16 ? (uint8_t)(state >> (typesize - 24)) : 0)] ^ \
-                    table[4][(uint8_t)p[3] ^ (typesize > 24 ? (uint8_t)(state >> (typesize - 32)) : 0)] ^ \
-                    table[3][(uint8_t)p[4] ^ (typesize > 32 ? (uint8_t)(state >> (typesize - 40)) : 0)] ^ \
-                    table[2][(uint8_t)p[5] ^ (typesize > 40 ? (uint8_t)(state >> (typesize - 48)) : 0)] ^ \
-                    table[1][(uint8_t)p[6] ^ (typesize > 48 ? (uint8_t)(state >> (typesize - 56)) : 0)] ^ \
-                    table[0][(uint8_t)p[7] ^ (typesize > 56 ? (uint8_t)(state >> (typesize - 64)) : 0)];  \
-        }                                                                                                 \
-                                                                                                          \
-        int sh = typesize - 8;                                                                            \
-        for (; p < pp; p ++) {                                                                            \
-            state = table[0][(uint8_t)*p ^ (uint8_t)(state >> sh)] ^ (state << 8);                        \
-        }                                                                                                 \
-                                                                                                          \
-        return state >> (typesize - bitsize);                                                             \
-    }                                                                                                     \
-
-IMP_BUILD_TABLE(build_table8_u8, uint8_t);
-IMP_CRC_UPDATE(crc_update_u8, uint8_t);
-IMP_BUILD_TABLE(build_table8_u16, uint16_t);
-IMP_CRC_UPDATE(crc_update_u16, uint16_t);
-IMP_BUILD_TABLE(build_table8_u32, uint32_t);
-IMP_CRC_UPDATE(crc_update_u32, uint32_t);
-IMP_BUILD_TABLE(build_table8_u64, uint64_t);
-IMP_CRC_UPDATE(crc_update_u64, uint64_t);
-#ifdef HAVE_TYPE_UINT128_T
-IMP_BUILD_TABLE(build_table8_u128, uint128_t);
-IMP_CRC_UPDATE(crc_update_u128, uint128_t);
-#endif
-
-#undef IMP_BUILD_TABLE
-
-#define IMP_BUILD_REFLECT_TABLE(NAME, TYPE, BITREFLECT)             \
-    static void                                                     \
-    NAME(TYPE table[8][256], int bitsize, TYPE poly)                \
-    {                                                               \
-        static const int typesize = sizeof(TYPE) * CHAR_BIT;        \
-        poly = BITREFLECT(poly << (typesize - bitsize));            \
-        TYPE (*t)[256] = table;                                     \
-        int s, b, i;                                                \
-        for (s = 0; s < 8; s ++) {                                  \
-            TYPE *p = *t;                                           \
-            for (b = 0; b < 256; b ++) {                            \
-                TYPE r = (s == 0) ? (TYPE)b : t[-1][b];             \
-                for (i = 0; i < 8; i ++) {                          \
-                    r = (r >> 1) ^ (poly & -(r & 1));               \
-                }                                                   \
-                *p ++ = r;                                          \
-            }                                                       \
-            t ++;                                                   \
-        }                                                           \
-    }                                                               \
-
-#define IMP_CRC_REFLECT_UPDATE(NAME, TYPE)                                                   \
-    static TYPE                                                                              \
-    NAME(int bitsize, const TYPE table[8][256],                                              \
-            const char *p, const char *pp, TYPE state)                                       \
-    {                                                                                        \
-        static const int typesize = sizeof(TYPE) * CHAR_BIT;                                 \
-        const char *pp8 = ((pp - p) & ~0x07) + p;                                            \
-        for (; p < pp8; p += 8) {                                                            \
-            state = table[7][(uint8_t)p[0] ^                  (uint8_t)(state >>  0)     ] ^ \
-                    table[6][(uint8_t)p[1] ^ (typesize >  8 ? (uint8_t)(state >>  8) : 0)] ^ \
-                    table[5][(uint8_t)p[2] ^ (typesize > 16 ? (uint8_t)(state >> 16) : 0)] ^ \
-                    table[4][(uint8_t)p[3] ^ (typesize > 24 ? (uint8_t)(state >> 24) : 0)] ^ \
-                    table[3][(uint8_t)p[4] ^ (typesize > 32 ? (uint8_t)(state >> 32) : 0)] ^ \
-                    table[2][(uint8_t)p[5] ^ (typesize > 40 ? (uint8_t)(state >> 40) : 0)] ^ \
-                    table[1][(uint8_t)p[6] ^ (typesize > 48 ? (uint8_t)(state >> 48) : 0)] ^ \
-                    table[0][(uint8_t)p[7] ^ (typesize > 56 ? (uint8_t)(state >> 56) : 0)];  \
-        }                                                                                    \
-                                                                                             \
-        for (; p < pp; p ++) {                                                               \
-            state = table[0][(uint8_t)*p ^ (uint8_t)state] ^ (state >> 8);                   \
-        }                                                                                    \
-                                                                                             \
-        return state;                                                                        \
-    }                                                                                        \
-
-IMP_BUILD_REFLECT_TABLE(build_reflect_table8_u8, uint8_t, bitreflect8);
-IMP_CRC_REFLECT_UPDATE(crc_reflect_update_u8, uint8_t);
-IMP_BUILD_REFLECT_TABLE(build_reflect_table8_u16, uint16_t, bitreflect16);
-IMP_CRC_REFLECT_UPDATE(crc_reflect_update_u16, uint16_t);
-IMP_BUILD_REFLECT_TABLE(build_reflect_table8_u32, uint32_t, bitreflect32);
-IMP_CRC_REFLECT_UPDATE(crc_reflect_update_u32, uint32_t);
-IMP_BUILD_REFLECT_TABLE(build_reflect_table8_u64, uint64_t, bitreflect64);
-IMP_CRC_REFLECT_UPDATE(crc_reflect_update_u64, uint64_t);
 #ifdef HAVE_TYPE_UINT128_T
-IMP_BUILD_REFLECT_TABLE(build_reflect_table8_u128, uint128_t, bitreflect128);
-IMP_CRC_REFLECT_UPDATE(crc_reflect_update_u128, uint128_t);
+#   define CRC_TYPE                 uint128_t
+#   define CRC_BITREFLECT           bitreflect128
+#   define CRC_BUILD_TABLES         crc_build_tables_u128
+#   define CRC_UPDATE               crc_update_u128
+#   define CRC_BUILD_REFLECT_TABLES crc_build_reflect_tables_u128
+#   define CRC_REFLECT_UPDATE       crc_reflect_update_u128
+#   include "crc_imps.h"
 #endif
 
-#undef IMP_BUILD_REFLECT_TABLE
-#undef IMP_CRC_REFLECT_UPDATE
 
 /*
  *
@@ -396,21 +326,14 @@ struct generator
     int bitsize;
     int flags; /* int type, refin, refout */
     anyuint_t bitmask, polynomial, initial, xorout;
-    union {
-        uint8_t as8[8][256];
-        uint16_t as16[8][256];
-        uint32_t as32[8][256];
-        uint64_t as64[8][256];
-#ifdef HAVE_TYPE_UINT128_T
-        uint128_t as128[8][256];
-#endif
-    } table[0];
+    const void *table; /* entity is String buffer as instance variable */
 };
 
 static VALUE mCRC;          /* module CRC */
 static VALUE mUtils;        /* module CRC::Utils */
 static VALUE cGenerator;    /* class CRC::Generator */
 static ID generator_iv_name;
+static ID generator_iv_table_buffer;
 
 static const rb_data_type_t generator_type = {
     .wrap_struct_name = "crc-turbo.CRC::Generator",
@@ -480,10 +403,11 @@ generator_init(int argc, VALUE argv[], VALUE obj)
     generator_init_args(argc, argv, &flags, &bitsize, &poly, &init, &xorout, &name);
 
     struct generator *p;
-    size_t allocsize = sizeof(struct generator) + (flags & TYPE_MASK) * 256 * 8;
+    size_t allocsize = sizeof(struct generator);
     RTYPEDDATA_DATA(obj) = p = (struct generator *)ALLOC_N(char, allocsize);
     p->bitsize = bitsize;
-    p->flags = flags | TABLE_NOTREADY;
+    p->flags = flags;
+    p->table = NULL;
 
     /*
      * bitmask の代入でわざわざ1ビット分を後から行う理由は、
@@ -533,11 +457,11 @@ generator_polynomial(VALUE t)
 {
     struct generator *p = get_generator(t);
     SWITCH_BY_TYPE(p->flags,
-            return conv_uint8(p->bitmask.as8),
-            return conv_uint16(p->bitmask.as16),
-            return conv_uint32(p->bitmask.as32),
-            return conv_uint64(p->bitmask.as64),
-            return conv_uint128(p->bitmask.as128));
+            return conv_uint8(p->polynomial.as8),
+            return conv_uint16(p->polynomial.as16),
+            return conv_uint32(p->polynomial.as32),
+            return conv_uint64(p->polynomial.as64),
+            return conv_uint128(p->polynomial.as128));
 }
 
 static VALUE
@@ -553,7 +477,7 @@ generator_initial_state(VALUE t)
 }
 
 static VALUE
-generator_table8(VALUE t)
+generator_table(VALUE t)
 {
     struct generator *p = get_generator(t);
     rb_raise(rb_eNotImpError, "");
@@ -608,43 +532,49 @@ static VALUE
 generator_update(VALUE t, VALUE seq, VALUE state)
 {
     struct generator *p = get_generator(t);
+    rb_check_type(seq, RUBY_T_STRING);
+    const char *q = RSTRING_PTR(seq);
+    const char *qq = q + RSTRING_LEN(seq);
 
-    if (p->flags & TABLE_NOTREADY) {
+    if (!p->table) {
+        size_t tablebytes = (p->flags & TYPE_MASK) * 16 * 256;
+        VALUE tablebuf = rb_str_buf_new(tablebytes);
+        rb_str_set_len(tablebuf, tablebytes);
+        void *table = RSTRING_PTR(tablebuf);
         if (p->flags & REFLECT_INPUT) {
             SWITCH_BY_TYPE(p->flags,
-                    build_reflect_table8_u8(p->table[0].as8, p->bitsize, p->polynomial.as8),
-                    build_reflect_table8_u16(p->table[0].as16, p->bitsize, p->polynomial.as16),
-                    build_reflect_table8_u32(p->table[0].as32, p->bitsize, p->polynomial.as32),
-                    build_reflect_table8_u64(p->table[0].as64, p->bitsize, p->polynomial.as64),
-                    build_reflect_table8_u128(p->table[0].as128, p->bitsize, p->polynomial.as128));
+                    crc_build_reflect_tables_u8(p->bitsize, table, p->polynomial.as8, 16),
+                    crc_build_reflect_tables_u16(p->bitsize, table, p->polynomial.as16, 16),
+                    crc_build_reflect_tables_u32(p->bitsize, table, p->polynomial.as32, 16),
+                    crc_build_reflect_tables_u64(p->bitsize, table, p->polynomial.as64, 16),
+                    crc_build_reflect_tables_u128(p->bitsize, table, p->polynomial.as128, 16));
         } else {
             SWITCH_BY_TYPE(p->flags,
-                    build_table8_u8(p->table[0].as8, p->bitsize, p->polynomial.as8),
-                    build_table8_u16(p->table[0].as16, p->bitsize, p->polynomial.as16),
-                    build_table8_u32(p->table[0].as32, p->bitsize, p->polynomial.as32),
-                    build_table8_u64(p->table[0].as64, p->bitsize, p->polynomial.as64),
-                    build_table8_u128(p->table[0].as128, p->bitsize, p->polynomial.as128));
+                    crc_build_tables_u8(p->bitsize, table, p->polynomial.as8, 16),
+                    crc_build_tables_u16(p->bitsize, table, p->polynomial.as16, 16),
+                    crc_build_tables_u32(p->bitsize, table, p->polynomial.as32, 16),
+                    crc_build_tables_u64(p->bitsize, table, p->polynomial.as64, 16),
+                    crc_build_tables_u128(p->bitsize, table, p->polynomial.as128, 16));
         }
-        p->flags ^= TABLE_NOTREADY;
+        rb_ivar_set(t, generator_iv_table_buffer, tablebuf);
+        rb_obj_freeze(tablebuf);
+        p->table = table;
     }
 
-    rb_check_type(seq, RUBY_T_STRING);
-    const char *q = RSTRING_PTR(seq);
-    const char *qq = q + RSTRING_LEN(seq);
     if (p->flags & REFLECT_INPUT) {
         SWITCH_BY_TYPE(p->flags,
-                return conv_uint8(crc_reflect_update_u8(p->bitsize, p->table[0].as8, q, qq, to_uint8(state))),
-                return conv_uint16(crc_reflect_update_u16(p->bitsize, p->table[0].as16, q, qq, to_uint16(state))),
-                return conv_uint32(crc_reflect_update_u32(p->bitsize, p->table[0].as32, q, qq, to_uint32(state))),
-                return conv_uint64(crc_reflect_update_u64(p->bitsize, p->table[0].as64, q, qq, to_uint64(state))),
-                return conv_uint128(crc_reflect_update_u128(p->bitsize, p->table[0].as128, q, qq, to_uint128(state))));
+                return conv_uint8(crc_reflect_update_u8(p->bitsize, p->table, q, qq, to_uint8(state))),
+                return conv_uint16(crc_reflect_update_u16(p->bitsize, p->table, q, qq, to_uint16(state))),
+                return conv_uint32(crc_reflect_update_u32(p->bitsize, p->table, q, qq, to_uint32(state))),
+                return conv_uint64(crc_reflect_update_u64(p->bitsize, p->table, q, qq, to_uint64(state))),
+                return conv_uint128(crc_reflect_update_u128(p->bitsize, p->table, q, qq, to_uint128(state))));
     } else {
         SWITCH_BY_TYPE(p->flags,
-                return conv_uint8(crc_update_u8(p->bitsize, p->table[0].as8, q, qq, to_uint8(state))),
-                return conv_uint16(crc_update_u16(p->bitsize, p->table[0].as16, q, qq, to_uint16(state))),
-                return conv_uint32(crc_update_u32(p->bitsize, p->table[0].as32, q, qq, to_uint32(state))),
-                return conv_uint64(crc_update_u64(p->bitsize, p->table[0].as64, q, qq, to_uint64(state))),
-                return conv_uint128(crc_update_u128(p->bitsize, p->table[0].as128, q, qq, to_uint128(state))));
+                return conv_uint8(crc_update_u8(p->bitsize, p->table, q, qq, to_uint8(state))),
+                return conv_uint16(crc_update_u16(p->bitsize, p->table, q, qq, to_uint16(state))),
+                return conv_uint32(crc_update_u32(p->bitsize, p->table, q, qq, to_uint32(state))),
+                return conv_uint64(crc_update_u64(p->bitsize, p->table, q, qq, to_uint64(state))),
+                return conv_uint128(crc_update_u128(p->bitsize, p->table, q, qq, to_uint128(state))));
     }
 }
 
@@ -679,10 +609,27 @@ utils_s_bitref64(VALUE mod, VALUE num)
 static VALUE
 utils_s_bitref128(VALUE mod, VALUE num)
 {
-#ifdef HAVE_TYPE_UINT128_T
-    return conv_uint128(bitreflect128(to_uint128(num)));
-#endif
-    rb_raise(rb_eNotImpError, "");
+    if (sizeof(unsigned long) < 16) {
+        static const int len = sizeof(char[16]) / sizeof(unsigned long);
+        unsigned long tmp[len + 1];
+        rb_big_pack(num, tmp, len);
+        unsigned long *p = tmp;
+        unsigned long *q = p + len;
+        while (p < q) {
+            unsigned long tmp1 = bitreflect_ulong(*p);
+            *p ++ = bitreflect_ulong(*-- q);
+            *q = tmp1;
+        }
+        tmp[len] = 0;
+        return rb_big_unpack(tmp, len + 1);
+    } else {
+        unsigned long n[2];
+        rb_big_pack(num, n, 1);
+        n[0] =  (unsigned long)bitreflect64(n[0] >> 64)       |
+               ((unsigned long)bitreflect64(n[0]      ) << 64);
+        n[1] = 0;
+        return rb_big_unpack(n, 2);
+    }
 }
 
 /*
@@ -693,6 +640,7 @@ void
 Init__turbo(void)
 {
     generator_iv_name = rb_intern("crc-turbo.CRC::Generator.name");
+    generator_iv_table_buffer = rb_intern("crc-turbo.CRC::Generator.table-buffer");
 
     mCRC = rb_define_module("CRC");
 
@@ -710,7 +658,7 @@ Init__turbo(void)
     rb_define_method(cGenerator, "bitmask", generator_bitmask, 0);
     rb_define_method(cGenerator, "polynomial", generator_polynomial, 0);
     rb_define_method(cGenerator, "initial_state", generator_initial_state, 0);
-    rb_define_method(cGenerator, "table8", generator_table8, 0);
+    rb_define_method(cGenerator, "table", generator_table, 0);
     rb_define_method(cGenerator, "reflect_input", generator_reflect_input, 0);
     rb_define_method(cGenerator, "reflect_output", generator_reflect_output, 0);
     rb_define_method(cGenerator, "xor_output", generator_xor_output, 0);

data/gemstub.rb

@@ -1,19 +1,19 @@
 GEMSTUB = Gem::Specification.new do |s|
   s.name = "crc-turbo"
-  s.version = "0.1"
+  s.version = "0.2"
   s.summary = "general CRC generator"
   s.description = <<EOS
 This is a C extention for "crc" gem library.
-Just install this, and "require 'crc'". Additional other work is not required.
+Just install this, and to do "require 'crc'" only. Additional other work is not required.
 EOS
   s.homepage = "https://osdn.jp/projects/rutsubo/"
-  s.license = "BSD-2-Clause"
+  s.licenses = ["BSD-2-Clause", "CC0-1.0"]
   s.author = "dearblue"
   s.email = "dearblue@users.osdn.me"
 
   s.required_ruby_version = ">= 2.0"
   s.add_development_dependency "rake", "~> 11.0"
-  s.add_runtime_dependency "crc", "~> 0.1"
+  s.add_runtime_dependency "crc", "~> 0.2"
 end
 
 EXTMAP["crc"] = "crc/_turbo"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: crc-turbo
 version: !ruby/object:Gem::Version
-  version: '0.1'
+  version: '0.2'
 platform: ruby
 authors:
 - dearblue
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-08 00:00:00.000000000 Z
+date: 2016-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -30,35 +30,40 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.2'
 description: |
   This is a C extention for "crc" gem library.
-  Just install this, and "require 'crc'". Additional other work is not required.
+  Just install this, and to do "require 'crc'" only. Additional other work is not required.
 email: dearblue@users.osdn.me
 executables: []
 extensions:
 - ext/crc/extconf.rb
 extra_rdoc_files:
+- HISTORY.ja.md
 - LICENSE
 - README.md
+- ext/crc/crc_imps.h
 - ext/crc/crcturbo.c
 files:
+- HISTORY.ja.md
 - LICENSE
 - README.md
 - Rakefile
+- ext/crc/crc_imps.h
 - ext/crc/crcturbo.c
 - ext/crc/extconf.rb
 - gemstub.rb
 homepage: https://osdn.jp/projects/rutsubo/
 licenses:
 - BSD-2-Clause
+- CC0-1.0
 metadata: {}
 post_install_message: 
 rdoc_options:
@@ -80,7 +85,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.2
+rubygems_version: 2.6.4
 signing_key: 
 specification_version: 4
 summary: general CRC generator