yencode 1.1.0 → 1.1.3

package/binding.gyp

@@ -1,9 +1,9 @@
 {
+  "variables": {
+    "enable_native_tuning%": 1,
+    "disable_avx256%": 0
+  },
   "target_defaults": {
-    "variables": {
-      "enable_native_tuning%": 1,
-      "disable_avx256%": 0
-    },
     "conditions": [
       ['target_arch=="ia32"', {
         "msvs_settings": {"VCCLCompilerTool": {"EnableEnhancedInstructionSet": "2"}}
@@ -41,7 +41,7 @@
       ['disable_avx256!=0', {
         "defines": ["YENC_DISABLE_AVX256=1"]
       }],
-      ['enable_native_tuning!=0', {
+      ['OS!="win" and enable_native_tuning!=0', {
         "defines": ["YENC_BUILD_NATIVE=1"]
       }]
     ],
@@ -64,7 +64,7 @@
   "targets": [
     {
       "target_name": "yencode",
-      "dependencies": ["crcutil", "yencode_sse2", "yencode_ssse3", "yencode_clmul", "yencode_avx", "yencode_avx2", "yencode_neon", "yencode_armcrc"],
+      "dependencies": ["crcutil", "yencode_sse2", "yencode_ssse3", "yencode_clmul", "yencode_clmul256", "yencode_avx", "yencode_avx2", "yencode_vbmi2", "yencode_neon", "yencode_armcrc"],
       "sources": [
         "src/yencode.cc",
         "src/platform.cc",
@@ -128,7 +128,7 @@
       "target_name": "yencode_clmul",
       "type": "static_library",
       "sources": [
-        "src/crc_folding.c"
+        "src/crc_folding.cc"
       ],
       "cflags!": ["-fno-omit-frame-pointer", "-fno-tree-vrp", "-fno-strict-aliasing"],
       "cxxflags!": ["-fno-omit-frame-pointer", "-fno-tree-vrp", "-fno-strict-aliasing"],
@@ -206,6 +206,70 @@
         }]
       ]
     },
+    {
+      "target_name": "yencode_clmul256",
+      "type": "static_library",
+      "sources": [
+        "src/crc_folding_256.cc"
+      ],
+      "cflags!": ["-fno-omit-frame-pointer", "-fno-tree-vrp", "-fno-strict-aliasing"],
+      "cxxflags!": ["-fno-omit-frame-pointer", "-fno-tree-vrp", "-fno-strict-aliasing"],
+      "xcode_settings": {
+        "OTHER_CFLAGS!": ["-fno-omit-frame-pointer", "-fno-tree-vrp", "-fno-strict-aliasing"],
+        "OTHER_CXXFLAGS!": ["-fno-omit-frame-pointer", "-fno-tree-vrp", "-fno-strict-aliasing"]
+      },
+      "msvs_settings": {"VCCLCompilerTool": {"BufferSecurityCheck": "false"}},
+      "conditions": [
+        ['target_arch in "ia32 x64" and OS!="win"', {
+          "variables": {"supports_vpclmul%": "<!(<!(echo ${CC_target:-${CC:-cc}}) -MM -E src/crc_folding_256.cc -mavx2 -mvpclmulqdq 2>/dev/null || true)"},
+          "conditions": [
+            ['supports_vpclmul!=""', {
+              "cflags": ["-mavx2", "-mvpclmulqdq", "-mpclmul"],
+              "cxxflags": ["-mavx2", "-mvpclmulqdq", "-mpclmul"],
+              "xcode_settings": {
+                "OTHER_CFLAGS": ["-mavx2", "-mvpclmulqdq", "-mpclmul"],
+                "OTHER_CXXFLAGS": ["-mavx2", "-mvpclmulqdq", "-mpclmul"],
+              }
+            }]
+          ]
+        }],
+        ['target_arch in "ia32 x64" and OS=="win"', {
+          "msvs_settings": {"VCCLCompilerTool": {"EnableEnhancedInstructionSet": "3"}}
+        }]
+      ]
+    },
+    {
+      "target_name": "yencode_vbmi2",
+      "type": "static_library",
+      "sources": [
+        "src/decoder_vbmi2.cc", "src/encoder_vbmi2.cc"
+      ],
+      "cflags!": ["-fno-omit-frame-pointer", "-fno-tree-vrp", "-fno-strict-aliasing"],
+      "cxxflags!": ["-fno-omit-frame-pointer", "-fno-tree-vrp", "-fno-strict-aliasing"],
+      "xcode_settings": {
+        "OTHER_CFLAGS!": ["-fno-omit-frame-pointer", "-fno-tree-vrp", "-fno-strict-aliasing"],
+        "OTHER_CXXFLAGS!": ["-fno-omit-frame-pointer", "-fno-tree-vrp", "-fno-strict-aliasing"]
+      },
+      "msvs_settings": {"VCCLCompilerTool": {"BufferSecurityCheck": "false"}},
+      "conditions": [
+        ['target_arch in "ia32 x64" and OS!="win"', {
+          "variables": {"supports_vbmi2%": "<!(<!(echo ${CC_target:-${CC:-cc}}) -MM -E src/encoder_vbmi2.cc -mavx512vl -mavx512vbmi2 2>/dev/null || true)"},
+          "conditions": [
+            ['supports_vbmi2!=""', {
+              "cflags": ["-mavx512vbmi2", "-mavx512vl", "-mavx512bw", "-mpopcnt", "-mbmi", "-mbmi2", "-mlzcnt"],
+              "cxxflags": ["-mavx512vbmi2", "-mavx512vl", "-mavx512bw", "-mpopcnt", "-mbmi", "-mbmi2", "-mlzcnt"],
+              "xcode_settings": {
+                "OTHER_CFLAGS": ["-mavx512vbmi2", "-mavx512vl", "-mavx512bw", "-mpopcnt", "-mbmi", "-mbmi2", "-mlzcnt"],
+                "OTHER_CXXFLAGS": ["-mavx512vbmi2", "-mavx512vl", "-mavx512bw", "-mpopcnt", "-mbmi", "-mbmi2", "-mlzcnt"],
+              }
+            }]
+          ]
+        }],
+        ['target_arch in "ia32 x64" and OS=="win"', {
+          "msvs_settings": {"VCCLCompilerTool": {"AdditionalOptions": ["/arch:AVX512"], "EnableEnhancedInstructionSet": "0"}}
+        }]
+      ]
+    },
     {
       "target_name": "yencode_neon",
       "type": "static_library",
@@ -260,6 +324,14 @@
             "OTHER_CFLAGS": ["-march=armv8-a+crc"],
             "OTHER_CXXFLAGS": ["-march=armv8-a+crc"],
           }
+        }],
+        ['OS!="win" and target_arch=="arm"', {
+          "cflags": ["-mfpu=fp-armv8"],
+          "cxxflags": ["-mfpu=fp-armv8"],
+          "xcode_settings": {
+            "OTHER_CFLAGS": ["-mfpu=fp-armv8"],
+            "OTHER_CXXFLAGS": ["-mfpu=fp-armv8"]
+          }
         }]
       ]
     },

package/crcutil-1.0/code/multiword_64_64_intrinsic_i386_mmx.cc

@@ -16,7 +16,7 @@
 
 #include "generic_crc.h"
 
-#if CRCUTIL_USE_ASM && HAVE_I386 && HAVE_MMX
+#if CRCUTIL_USE_ASM && HAVE_I386 && HAVE_MMX && !defined(_MSC_VER) && !(defined(__GNUC__) && !defined(__clang__))
 
 namespace crcutil {
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yencode",
-  "version": "1.1.0",
+  "version": "1.1.3",
   "description": "SIMD accelerated yEnc encoder/decoder and CRC32 calculator",
   "keywords": [
     "yenc",

package/src/common.h

@@ -8,7 +8,7 @@
     defined(__LP64    ) || \
     defined(_M_X64    ) || \
     defined(_M_AMD64  ) || \
-    defined(_WIN64    )
+    (defined(_WIN64) && !defined(_M_ARM64))
 	#define PLATFORM_AMD64 1
 #endif
 #if defined(PLATFORM_AMD64) || \
@@ -18,7 +18,7 @@
     defined(__i686__  ) || \
     defined(_M_I86    ) || \
     defined(_M_IX86   ) || \
-    defined(_WIN32    )
+    (defined(_WIN32) && !defined(_M_ARM) && !defined(_M_ARM64))
 	#define PLATFORM_X86 1
 #endif
 #if defined(__aarch64__) || \
@@ -35,15 +35,21 @@
 #endif
 
 
-#if defined(__cplusplus) && __cplusplus > 201100 && !(defined(_MSC_VER) && defined(__clang__))
-	// C++11 method
+#include <stdlib.h>
+#if defined(_MSC_VER) || defined(__MINGW32__) || defined(__MINGW64__)
+	// MSVC doesn't support C11 aligned_alloc: https://stackoverflow.com/a/62963007
+	#define ALIGN_ALLOC(buf, len, align) *(void**)&(buf) = _aligned_malloc((len), align)
+	#define ALIGN_FREE _aligned_free
+#elif defined(_ISOC11_SOURCE)
+	// C11 method
 	// len needs to be a multiple of alignment, although it sometimes works if it isn't...
-	#include <cstdlib>
 	#define ALIGN_ALLOC(buf, len, align) *(void**)&(buf) = aligned_alloc(align, ((len) + (align)-1) & ~((align)-1))
 	#define ALIGN_FREE free
-#elif defined(_MSC_VER)
-	#define ALIGN_ALLOC(buf, len, align) *(void**)&(buf) = _aligned_malloc((len), align)
-	#define ALIGN_FREE _aligned_free
+#elif defined(__cplusplus) && __cplusplus >= 201700
+	// C++17 method
+	#include <cstdlib>
+	#define ALIGN_ALLOC(buf, len, align) *(void**)&(buf) = std::aligned_alloc(align, ((len) + (align)-1) & ~((align)-1))
+	#define ALIGN_FREE free
 #else
 	#define ALIGN_ALLOC(buf, len, align) if(posix_memalign((void**)&(buf), align, (len))) (buf) = NULL
 	#define ALIGN_FREE free
@@ -51,7 +57,7 @@
 
 
 // MSVC compatibility
-#if (defined(_M_IX86_FP) && _M_IX86_FP == 2) || defined(_M_X64)
+#if ((defined(_M_IX86_FP) && _M_IX86_FP == 2) || defined(_M_X64)) && !defined(__clang__)
 	#define __SSE2__ 1
 	#define __SSSE3__ 1
 	#define __SSE4_1__ 1
@@ -85,12 +91,16 @@
 	#define __ARM_NEON 1
 #endif
 #if defined(_M_ARM)
-	/*#define __ARM_NEON 1*/
+	#define __ARM_NEON 1
 #endif
 #ifdef _MSC_VER
-#define __BYTE_ORDER__ 1234
-#define __ORDER_BIG_ENDIAN__ 4321
-#include <intrin.h>
+# ifndef __BYTE_ORDER__
+#  define __BYTE_ORDER__ 1234
+# endif
+# ifndef __ORDER_BIG_ENDIAN__
+#  define __ORDER_BIG_ENDIAN__ 4321
+# endif
+# include <intrin.h>
 #endif
 
 
@@ -137,6 +147,59 @@
 
 #ifdef __ARM_NEON
 # include <arm_neon.h>
+
+// ARM provides no standard way to inline define a vector :(
+static HEDLEY_ALWAYS_INLINE uint8x8_t vmake_u8(
+	uint8_t a, uint8_t b, uint8_t c, uint8_t d, uint8_t e, uint8_t f, uint8_t g, uint8_t h
+) {
+# if defined(_MSC_VER)
+	uint8_t t[] = {a,b,c,d,e,f,g,h};
+	return vld1_u8(t);
+# else
+	return (uint8x8_t){a,b,c,d,e,f,g,h};
+# endif
+}
+static HEDLEY_ALWAYS_INLINE uint8x16_t vmakeq_u8(
+	uint8_t a, uint8_t b, uint8_t c, uint8_t d, uint8_t e, uint8_t f, uint8_t g, uint8_t h,
+	uint8_t i, uint8_t j, uint8_t k, uint8_t l, uint8_t m, uint8_t n, uint8_t o, uint8_t p
+) {
+# if defined(_MSC_VER)
+	uint8_t t[] = {a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p};
+	return vld1q_u8(t);
+# else
+	return (uint8x16_t){a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p};
+# endif
+}
+static HEDLEY_ALWAYS_INLINE int8x16_t vmakeq_s8(
+	int8_t a, int8_t b, int8_t c, int8_t d, int8_t e, int8_t f, int8_t g, int8_t h,
+	int8_t i, int8_t j, int8_t k, int8_t l, int8_t m, int8_t n, int8_t o, int8_t p
+) {
+# if defined(_MSC_VER)
+	int8_t t[] = {a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p};
+	return vld1q_s8(t);
+# else
+	return (int8x16_t){a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p};
+# endif
+}
+
+# ifdef _MSC_VER
+#  define _CREATE_TUPLE(type, ...) type{{ __VA_ARGS__ }}
+# else
+#  define _CREATE_TUPLE(type, ...) (type){{ __VA_ARGS__ }}
+# endif
+static HEDLEY_ALWAYS_INLINE uint8x16x2_t vcreate2_u8(uint8x16_t a, uint8x16_t b) {
+	return _CREATE_TUPLE(uint8x16x2_t, a, b);
+}
+static HEDLEY_ALWAYS_INLINE int8x16x2_t vcreate2_s8(int8x16_t a, int8x16_t b) {
+	return _CREATE_TUPLE(int8x16x2_t, a, b);
+}
+static HEDLEY_ALWAYS_INLINE uint8x16x3_t vcreate3_u8(uint8x16_t a, uint8x16_t b, uint8x16_t c) {
+	return _CREATE_TUPLE(uint8x16x3_t, a, b, c);
+}
+static HEDLEY_ALWAYS_INLINE uint8x16x4_t vcreate4_u8(uint8x16_t a, uint8x16_t b, uint8x16_t c, uint8x16_t d) {
+	return _CREATE_TUPLE(uint8x16x4_t, a, b, c, d);
+}
+# undef _CREATE_TUPLE
 #endif
 #ifdef PLATFORM_ARM
 bool cpu_supports_neon();
@@ -158,9 +221,9 @@ enum YEncDecIsaLevel {
 	ISA_LEVEL_SSE41 = 0x300,
 	ISA_LEVEL_SSE4_POPCNT = 0x301,
 	ISA_LEVEL_AVX = 0x381, // same as above, just used as a differentiator for `cpu_supports_isa`
-	ISA_LEVEL_AVX2 = 0x383, // also includes BMI1/2 and LZCNT
-	ISA_LEVEL_AVX3 = 0x403, // SKX variant; AVX512VL + AVX512BW
-	ISA_LEVEL_VBMI2 = 0x503 // ICL
+	ISA_LEVEL_AVX2 = 0x403, // also includes BMI1/2 and LZCNT
+	ISA_LEVEL_AVX3 = 0x503, // SKX variant; AVX512VL + AVX512BW
+	ISA_LEVEL_VBMI2 = 0x603 // ICL
 };
 #ifdef _MSC_VER
 // native tuning not supported in MSVC
@@ -190,13 +253,6 @@ enum YEncDecIsaLevel {
 # endif
 #endif
 
-#ifdef _MSC_VER
-# define _cpuid1(ar) __cpuid(ar, 1)
-#else
-# include <cpuid.h>
-# define _cpuid1(ar) __cpuid(1, ar[0], ar[1], ar[2], ar[3])
-#endif
-
 int cpu_supports_isa();
 #endif // PLATFORM_X86
 
@@ -211,7 +267,7 @@ int cpu_supports_isa();
 
 
 // GCC 8/9/10(dev) fails to optimize cases where KNOT should be used, so use intrinsic explicitly; Clang 6+ has no issue, but Clang 6/7 doesn't have the intrinsic; MSVC 2019 also fails and lacks the intrinsic
-#if defined(__GNUC__) && __GNUC__ >= 7
+#if (defined(__GNUC__) && __GNUC__ >= 7) || (defined(_MSC_VER) && _MSC_VER >= 1924)
 # define KNOT16 _knot_mask16
 # define KNOT32 _knot_mask32
 #else
@@ -219,6 +275,14 @@ int cpu_supports_isa();
 # define KNOT32(x) ((__mmask32)~(x))
 #endif
 
+// weird thing with Apple's Clang; doesn't seem to always occur, so assume that Clang >= 9 is fine: https://github.com/animetosho/node-yencode/issues/8#issuecomment-583385864
+// seems that Clang < 3.6 also uses the old name
+#if defined(__clang__) && ((defined(__APPLE__) && __clang_major__ < 9) || __clang_major__ < 3 || (__clang_major__ == 3 && __clang_minor__ < 6))
+# define _lzcnt_u32 __lzcnt32
+#endif
+
+
+
 #ifdef __GNUC__
 # if __GNUC__ >= 9
 #  define LIKELIHOOD(p, c) (HEDLEY_PREDICT(!!(c), 1, p))

package/src/crc.cc

@@ -1,54 +1,81 @@
-#include "common.h"
 #include "crc_common.h"
 
-
 #include "interface.h"
 crcutil_interface::CRC* crc = NULL;
 
-
-static void do_crc32_generic(const void* data, size_t length, unsigned char out[4]) {
-	crcutil_interface::UINT64 tmp = 0;
-	crc->Compute(data, length, &tmp);
-	UNPACK_4(out, tmp);
-}
-crc_func _do_crc32 = &do_crc32_generic;
-
-static void do_crc32_incremental_generic(const void* data, size_t length, unsigned char init[4]) {
-	crcutil_interface::UINT64 tmp = PACK_4(init);
+static uint32_t do_crc32_incremental_generic(const void* data, size_t length, uint32_t init) {
+	crcutil_interface::UINT64 tmp = init;
 	crc->Compute(data, length, &tmp);
-	UNPACK_4(init, tmp);
+	return (uint32_t)tmp;
 }
 crc_func _do_crc32_incremental = &do_crc32_incremental_generic;
 
 
 
-void do_crc32_combine(unsigned char crc1[4], const unsigned char crc2[4], size_t len2) {
-	crcutil_interface::UINT64 crc1_ = PACK_4(crc1), crc2_ = PACK_4(crc2);
+uint32_t do_crc32_combine(uint32_t crc1, uint32_t crc2, size_t len2) {
+	crcutil_interface::UINT64 crc1_ = crc1, crc2_ = crc2;
 	crc->Concatenate(crc2_, 0, len2, &crc1_);
-	UNPACK_4(crc1, crc1_);
+	return (uint32_t)crc1_;
 }
 
-void do_crc32_zeros(unsigned char crc1[4], size_t len) {
-	crcutil_interface::UINT64 crc_ = PACK_4(crc1);
+uint32_t do_crc32_zeros(uint32_t crc1, size_t len) {
+	crcutil_interface::UINT64 crc_ = crc1;
 	crc->CrcOfZeroes(len, &crc_);
-	UNPACK_4(crc1, crc_);
+	return (uint32_t)crc_;
 }
 
-extern "C" void crc_clmul_set_funcs(crc_func*, crc_func*);
-void crc_arm_set_funcs(crc_func*, crc_func*);
+void crc_clmul_set_funcs(crc_func*);
+void crc_clmul256_set_funcs(crc_func*);
+void crc_arm_set_funcs(crc_func*);
+
+#ifdef PLATFORM_X86
+int cpu_supports_crc_isa();
+#endif
 
+#if defined(PLATFORM_ARM) && defined(_WIN32)
+# define WIN32_LEAN_AND_MEAN
+# include <Windows.h>
+#endif
+#ifdef PLATFORM_ARM
+# ifdef __ANDROID__
+#  include <cpu-features.h>
+# elif defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD__ >= 12)
+#  include <sys/auxv.h>
+#  include <asm/hwcap.h>
+# elif (defined(__FreeBSD__) && __FreeBSD__ < 12)
+#  include <sys/sysctl.h>
+#  include <asm/hwcap.h>
+# elif defined(__APPLE__)
+#  include <sys/types.h>
+#  include <sys/sysctl.h>
+# endif
+# ifdef __FreeBSD__
+static unsigned long getauxval(unsigned long cap) {
+	unsigned long ret;
+	elf_aux_info(cap, &ret, sizeof(ret));
+	return ret;
+}
+# endif
+#endif
 void crc_init() {
 	crc = crcutil_interface::CRC::Create(
 		0xEDB88320, 0, 32, true, 0, 0, 0, 0, NULL);
 	// instance never deleted... oh well...
 	
 #ifdef PLATFORM_X86
-	int flags[4];
-	_cpuid1(flags);
-	if((flags[2] & 0x80202) == 0x80202) // SSE4.1 + SSSE3 + CLMUL
-		crc_clmul_set_funcs(&_do_crc32, &_do_crc32_incremental);
+	int support = cpu_supports_crc_isa();
+	if(support == 2)
+		crc_clmul256_set_funcs(&_do_crc32_incremental);
+	else if(support == 1)
+		crc_clmul_set_funcs(&_do_crc32_incremental);
 #endif
 #ifdef PLATFORM_ARM
+# ifdef __APPLE__
+	int supported = 0;
+	size_t len = sizeof(supported);
+	if(sysctlbyname("hw.optional.armv8_crc32", &supported, &len, NULL, 0))
+		supported = 0;
+# endif
 	if(
 # if defined(AT_HWCAP2) && defined(HWCAP2_CRC32)
 		getauxval(AT_HWCAP2) & HWCAP2_CRC32
@@ -56,14 +83,19 @@ void crc_init() {
 		getauxval(AT_HWCAP) & HWCAP_CRC32
 # elif defined(ANDROID_CPU_FAMILY_ARM) && defined(__aarch64__)
 		android_getCpuFeatures() & ANDROID_CPU_ARM64_FEATURE_CRC32
-	/* no 32-bit flag - presumably CRC not allowed on 32-bit CPUs on Android */
+# elif defined(ANDROID_CPU_FAMILY_ARM) /* aarch32 */
+		android_getCpuFeatures() & ANDROID_CPU_ARM_FEATURE_CRC32
+# elif defined(_WIN32)
+		IsProcessorFeaturePresent(PF_ARM_V8_CRC32_INSTRUCTIONS_AVAILABLE)
+# elif defined(__APPLE__)
+		supported
 # elif defined(__ARM_FEATURE_CRC32)
 		true /* assume available if compiled as such */
 # else
 		false
 # endif
 	) {
-		crc_arm_set_funcs(&_do_crc32, &_do_crc32_incremental);
+		crc_arm_set_funcs(&_do_crc32_incremental);
 	}
 #endif
 }

package/src/crc.h

@@ -1,9 +1,23 @@
+#ifndef __YENC_CRC_H
+#define __YENC_CRC_H
 
-extern void (*_do_crc32)(const void* data, size_t length, unsigned char out[4]);
-#define do_crc32 (*_do_crc32)
-extern void (*_do_crc32_incremental)(const void* data, size_t length, unsigned char init[4]);
-#define do_crc32_incremental (*_do_crc32_incremental)
+#ifdef __cplusplus
+extern "C" {
+#endif
 
-void do_crc32_combine(unsigned char crc1[4], const unsigned char crc2[4], size_t len2);
-void do_crc32_zeros(unsigned char crc1[4], size_t len);
+
+
+typedef uint32_t (*crc_func)(const void*, size_t, uint32_t);
+extern crc_func _do_crc32_incremental;
+#define do_crc32 (*_do_crc32_incremental)
+
+uint32_t do_crc32_combine(uint32_t crc1, const uint32_t crc2, size_t len2);
+uint32_t do_crc32_zeros(uint32_t crc1, size_t len);
 void crc_init();
+
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif