yencode 1.1.4 → 1.1.5

package/package.json

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

package/src/common.h

@@ -221,6 +221,7 @@ bool cpu_supports_neon();
 
 #ifdef PLATFORM_X86
 enum YEncDecIsaLevel {
+	ISA_GENERIC = 0,
 	ISA_FEATURE_POPCNT = 0x1,
 	ISA_FEATURE_LZCNT = 0x2,
 	ISA_FEATURE_EVEX512 = 0x4, // AVX512 support
@@ -228,11 +229,30 @@ enum YEncDecIsaLevel {
 	ISA_LEVEL_SSSE3 = 0x200,
 	ISA_LEVEL_SSE41 = 0x300,
 	ISA_LEVEL_SSE4_POPCNT = 0x301,
+	ISA_LEVEL_PCLMUL = 0x340,
 	ISA_LEVEL_AVX = 0x381, // same as above, just used as a differentiator for `cpu_supports_isa`
 	ISA_LEVEL_AVX2 = 0x403, // also includes BMI1/2 and LZCNT
+	ISA_LEVEL_VPCLMUL = 0x440,
 	ISA_LEVEL_AVX3 = 0x507, // SKX variant; AVX512VL + AVX512BW
 	ISA_LEVEL_VBMI2 = 0x603 // ICL, AVX10
 };
+#elif defined(PLATFORM_ARM)
+enum YEncDecIsaLevel {
+	ISA_GENERIC = 0,
+	ISA_FEATURE_CRC = 8,
+	ISA_LEVEL_NEON = 0x1000
+};
+#elif defined(__riscv)
+enum YEncDecIsaLevel {
+	ISA_GENERIC = 0,
+	ISA_LEVEL_RVV = 0x10000
+};
+#else
+enum YEncDecIsaLevel {
+	ISA_GENERIC = 0
+};
+#endif
+#ifdef PLATFORM_X86
 #ifdef _MSC_VER
 // native tuning not supported in MSVC
 # define ISA_NATIVE ISA_LEVEL_SSE2

package/src/crc.cc

@@ -123,9 +123,10 @@ static void generate_crc32_slice_table() {
 }
 #endif
 
-
-crc_func _do_crc32_incremental = &do_crc32_incremental_generic;
-
+extern "C" {
+	crc_func _do_crc32_incremental = &do_crc32_incremental_generic;
+	int _crc32_isa = ISA_GENERIC;
+}
 
 
 uint32_t do_crc32_combine(uint32_t crc1, uint32_t crc2, size_t len2) {
@@ -140,9 +141,9 @@ uint32_t do_crc32_zeros(uint32_t crc1, size_t len) {
 	return (uint32_t)crc_;
 }
 
-void crc_clmul_set_funcs(crc_func*);
-void crc_clmul256_set_funcs(crc_func*);
-void crc_arm_set_funcs(crc_func*);
+void crc_clmul_set_funcs();
+void crc_clmul256_set_funcs();
+void crc_arm_set_funcs();
 
 #ifdef PLATFORM_X86
 int cpu_supports_crc_isa();
@@ -186,9 +187,9 @@ void crc_init() {
 #ifdef PLATFORM_X86
 	int support = cpu_supports_crc_isa();
 	if(support == 2)
-		crc_clmul256_set_funcs(&_do_crc32_incremental);
+		crc_clmul256_set_funcs();
 	else if(support == 1)
-		crc_clmul_set_funcs(&_do_crc32_incremental);
+		crc_clmul_set_funcs();
 #endif
 #ifdef PLATFORM_ARM
 # ifdef __APPLE__
@@ -216,7 +217,7 @@ void crc_init() {
 		false
 # endif
 	) {
-		crc_arm_set_funcs(&_do_crc32_incremental);
+		crc_arm_set_funcs();
 	}
 #endif
 }

package/src/crc.h

@@ -9,11 +9,15 @@ extern "C" {
 
 typedef uint32_t (*crc_func)(const void*, size_t, uint32_t);
 extern crc_func _do_crc32_incremental;
+extern int _crc32_isa;
 #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();
+static inline int crc32_isa_level() {
+	return _crc32_isa;
+}
 
 
 

package/src/crc_arm.cc

@@ -200,11 +200,10 @@ static uint32_t do_crc32_incremental_arm(const void* data, size_t length, uint32
 	return ~arm_crc_calc(~init, (const unsigned char*)data, (long)length);
 }
 
-void crc_arm_set_funcs(crc_func* _do_crc32_incremental) {
-	*_do_crc32_incremental = &do_crc32_incremental_arm;
+void crc_arm_set_funcs() {
+	_do_crc32_incremental = &do_crc32_incremental_arm;
+	_crc32_isa = ISA_FEATURE_CRC;
 }
 #else
-void crc_arm_set_funcs(crc_func* _do_crc32_incremental) {
-	(void)_do_crc32_incremental;
-}
+void crc_arm_set_funcs() {}
 #endif

package/src/crc_folding.cc

@@ -365,12 +365,11 @@ static uint32_t do_crc32_incremental_clmul(const void* data, size_t length, uint
 	return crc_fold((const unsigned char*)data, (long)length, init);
 }
 
-void crc_clmul_set_funcs(crc_func* _do_crc32_incremental) {
-	*_do_crc32_incremental = &do_crc32_incremental_clmul;
+void crc_clmul_set_funcs() {
+	_do_crc32_incremental = &do_crc32_incremental_clmul;
+	_crc32_isa = ISA_LEVEL_PCLMUL;
 }
 #else
-void crc_clmul_set_funcs(crc_func* _do_crc32_incremental) {
-    (void)_do_crc32_incremental;
-}
+void crc_clmul_set_funcs() {}
 #endif
 

package/src/crc_folding_256.cc

@@ -217,13 +217,14 @@ static uint32_t do_crc32_incremental_clmul(const void* data, size_t length, uint
 	return crc_fold((const unsigned char*)data, (long)length, init);
 }
 
-void crc_clmul256_set_funcs(crc_func* _do_crc32_incremental) {
-	*_do_crc32_incremental = &do_crc32_incremental_clmul;
+void crc_clmul256_set_funcs() {
+	_do_crc32_incremental = &do_crc32_incremental_clmul;
+	_crc32_isa = ISA_LEVEL_VPCLMUL;
 }
 #else
-void crc_clmul_set_funcs(crc_func* _do_crc32_incremental);
-void crc_clmul256_set_funcs(crc_func* _do_crc32_incremental) {
-	crc_clmul_set_funcs(_do_crc32_incremental);
+void crc_clmul_set_funcs();
+void crc_clmul256_set_funcs() {
+	crc_clmul_set_funcs();
 }
 #endif
 

package/src/decoder.cc

@@ -7,6 +7,8 @@ extern "C" {
 	YencDecoderEnd (*_do_decode)(const unsigned char**, unsigned char**, size_t, YencDecoderState*) = &do_decode_scalar<false, false>;
 	YencDecoderEnd (*_do_decode_raw)(const unsigned char**, unsigned char**, size_t, YencDecoderState*) = &do_decode_scalar<true, false>;
 	YencDecoderEnd (*_do_decode_end_raw)(const unsigned char**, unsigned char**, size_t, YencDecoderState*) = &do_decode_end_scalar<true>;
+	
+	int _decode_isa = ISA_GENERIC;
 }
 
 void decoder_set_sse2_funcs();
@@ -27,6 +29,7 @@ static inline void decoder_set_native_funcs() {
 	_do_decode = &do_decode_simd<false, false, sizeof(__m256i)*2, do_decode_avx2<false, false, ISA_NATIVE> >;
 	_do_decode_raw = &do_decode_simd<true, false, sizeof(__m256i)*2, do_decode_avx2<true, false, ISA_NATIVE> >;
 	_do_decode_end_raw = &do_decode_simd<true, true, sizeof(__m256i)*2, do_decode_avx2<true, true, ISA_NATIVE> >;
+	_decode_isa = ISA_NATIVE;
 }
 # else
 #  include "decoder_sse_base.h"
@@ -36,6 +39,7 @@ static inline void decoder_set_native_funcs() {
 	_do_decode = &do_decode_simd<false, false, sizeof(__m128i)*2, do_decode_sse<false, false, ISA_NATIVE> >;
 	_do_decode_raw = &do_decode_simd<true, false, sizeof(__m128i)*2, do_decode_sse<true, false, ISA_NATIVE> >;
 	_do_decode_end_raw = &do_decode_simd<true, true, sizeof(__m128i)*2, do_decode_sse<true, true, ISA_NATIVE> >;
+	_decode_isa = ISA_NATIVE;
 }
 # endif
 #endif

package/src/decoder.h

@@ -32,6 +32,7 @@ typedef enum {
 extern YencDecoderEnd (*_do_decode)(const unsigned char**, unsigned char**, size_t, YencDecoderState*);
 extern YencDecoderEnd (*_do_decode_raw)(const unsigned char**, unsigned char**, size_t, YencDecoderState*);
 extern YencDecoderEnd (*_do_decode_end_raw)(const unsigned char**, unsigned char**, size_t, YencDecoderState*);
+extern int _decode_isa;
 
 static inline size_t do_decode(int isRaw, const unsigned char* src, unsigned char* dest, size_t len, YencDecoderState* state) {
 	unsigned char* ds = dest;
@@ -45,6 +46,9 @@ static inline YencDecoderEnd do_decode_end(const unsigned char** src, unsigned c
 
 void decoder_init();
 
+static inline int decode_isa_level() {
+	return _decode_isa;
+}
 
 
 #ifdef __cplusplus

package/src/decoder_avx.cc

@@ -9,6 +9,7 @@ void decoder_set_avx_funcs() {
 	_do_decode = &do_decode_simd<false, false, sizeof(__m128i)*2, do_decode_sse<false, false, ISA_LEVEL_SSE4_POPCNT> >;
 	_do_decode_raw = &do_decode_simd<true, false, sizeof(__m128i)*2, do_decode_sse<true, false, ISA_LEVEL_SSE4_POPCNT> >;
 	_do_decode_end_raw = &do_decode_simd<true, true, sizeof(__m128i)*2, do_decode_sse<true, true, ISA_LEVEL_SSE4_POPCNT> >;
+	_decode_isa = ISA_LEVEL_AVX;
 }
 #else
 void decoder_set_ssse3_funcs();

package/src/decoder_avx2.cc

@@ -9,6 +9,7 @@ void decoder_set_avx2_funcs() {
 	_do_decode = &do_decode_simd<false, false, sizeof(__m256i)*2, do_decode_avx2<false, false, ISA_LEVEL_AVX2> >;
 	_do_decode_raw = &do_decode_simd<true, false, sizeof(__m256i)*2, do_decode_avx2<true, false, ISA_LEVEL_AVX2> >;
 	_do_decode_end_raw = &do_decode_simd<true, true, sizeof(__m256i)*2, do_decode_avx2<true, true, ISA_LEVEL_AVX2> >;
+	_decode_isa = ISA_LEVEL_AVX2;
 }
 #else
 void decoder_set_avx_funcs();

package/src/decoder_avx2_base.h

@@ -67,6 +67,8 @@ HEDLEY_ALWAYS_INLINE void do_decode_avx2(const uint8_t* src, long& len, unsigned
 		);
 	}
 	
+	decoder_set_nextMask<isRaw>(src, len, _nextMask); // set this before the loop because we can't check src after it's been overwritten
+	
 	// for some reason, MSVC Win32 seems to crash when trying to compile _mm256_mask_cmpeq_epi8_mask
 	// the crash can be fixed by switching the order of the last two arguments, but it seems to generate wrong code
 	// so just disable the optimisation as it seems to be problematic there
@@ -320,6 +322,7 @@ HEDLEY_ALWAYS_INLINE void do_decode_avx2(const uint8_t* src, long& len, unsigned
 							// terminator found
 							// there's probably faster ways to do this, but reverting to scalar code should be good enough
 							len += (long)i;
+							_nextMask = decoder_set_nextMask<isRaw>(src+i, mask);
 							break;
 						}
 					}
@@ -412,6 +415,7 @@ HEDLEY_ALWAYS_INLINE void do_decode_avx2(const uint8_t* src, long& len, unsigned
 						}
 						if(endFound) {
 							len += (long)i;
+							_nextMask = decoder_set_nextMask<isRaw>(src+i, mask);
 							break;
 						}
 					}
@@ -613,20 +617,6 @@ HEDLEY_ALWAYS_INLINE void do_decode_avx2(const uint8_t* src, long& len, unsigned
 		}
 	}
 	_escFirst = (unsigned char)escFirst;
-	if(isRaw) {
-		// this would be the trivial solution, but requires the compiler holding onto minMask throughout the loop:
-		//_nextMask = ~(uint16_t)_mm256_movemask_epi8(_mm256_cmpeq_epi8(minMask, _mm256_set1_epi8('.')));
-		// instead, just scan the memory to determine what to set nextMask to
-		if(len != 0) { // have to gone through at least one loop cycle
-			if(src[i-2] == '\r' && src[i-1] == '\n' && src[i] == '.')
-				_nextMask = 1;
-			else if(src[i-1] == '\r' && src[i] == '\n' && src[i+1] == '.')
-				_nextMask = 2;
-			else
-				_nextMask = 0;
-		}
-	} else
-		_nextMask = 0;
 	_mm256_zeroupper();
 }
 #endif

package/src/decoder_common.h

@@ -509,4 +509,29 @@ static inline void decoder_init_lut(uint8_t* eqFixLUT, void* compactLUT) {
 	}
 	#endif
 }
+template<bool isRaw>
+static inline void decoder_set_nextMask(const uint8_t* src, size_t len, uint16_t& nextMask) {
+	if(isRaw) {
+		if(len != 0) { // have to gone through at least one loop cycle
+			if(src[-2] == '\r' && src[-1] == '\n' && src[0] == '.')
+				nextMask = 1;
+			else if(src[-1] == '\r' && src[0] == '\n' && src[1] == '.')
+				nextMask = 2;
+			else
+				nextMask = 0;
+		}
+	} else
+		nextMask = 0;
+}
 
+// without backtracking
+template<bool isRaw>
+static inline uint16_t decoder_set_nextMask(const uint8_t* src, unsigned mask) {
+	if(isRaw) {
+		if(src[0] == '.')
+			return mask & 1;
+		if(src[1] == '.')
+			return mask & 2;
+	}
+	return 0;
+}

package/src/decoder_neon.cc

@@ -78,6 +78,9 @@ HEDLEY_ALWAYS_INLINE void do_decode_neon(const uint8_t* src, long& len, unsigned
 			lfCompare = vsetq_lane_u8('.', lfCompare, 1);
 	}
 #endif
+	
+	decoder_set_nextMask<isRaw>(src, len, nextMask);
+	
 	long i;
 	for(i = -len; i; i += sizeof(uint8x16_t)*2) {
 		uint8x16x2_t data = vld1q_u8_x2_align(src+i, 32);
@@ -251,6 +254,7 @@ HEDLEY_ALWAYS_INLINE void do_decode_neon(const uint8_t* src, long& len, unsigned
 							// terminator found
 							// there's probably faster ways to do this, but reverting to scalar code should be good enough
 							len += i;
+							nextMask = decoder_set_nextMask<isRaw>(src+i, mask);
 							break;
 						}
 					}
@@ -301,6 +305,7 @@ HEDLEY_ALWAYS_INLINE void do_decode_neon(const uint8_t* src, long& len, unsigned
 						);
 						if(LIKELIHOOD(0.001, neon_vect_is_nonzero(matchEnd))) {
 							len += i;
+							nextMask = decoder_set_nextMask<isRaw>(src+i, mask);
 							break;
 						}
 					}
@@ -449,18 +454,6 @@ HEDLEY_ALWAYS_INLINE void do_decode_neon(const uint8_t* src, long& len, unsigned
 #endif
 		}
 	}
-	
-	if(isRaw) {
-		if(len != 0) { // have to gone through at least one loop cycle
-			if(src[i-2] == '\r' && src[i-1] == '\n' && src[i] == '.')
-				nextMask = 1;
-			else if(src[i-1] == '\r' && src[i] == '\n' && src[i+1] == '.')
-				nextMask = 2;
-			else
-				nextMask = 0;
-		}
-	} else
-		nextMask = 0;
 }
 
 void decoder_set_neon_funcs() {
@@ -468,6 +461,7 @@ void decoder_set_neon_funcs() {
 	_do_decode = &do_decode_simd<false, false, sizeof(uint8x16_t)*2, do_decode_neon<false, false> >;
 	_do_decode_raw = &do_decode_simd<true, false, sizeof(uint8x16_t)*2, do_decode_neon<true, false> >;
 	_do_decode_end_raw = &do_decode_simd<true, true, sizeof(uint8x16_t)*2, do_decode_neon<true, true> >;
+	_decode_isa = ISA_LEVEL_NEON;
 }
 #else
 void decoder_set_neon_funcs() {}

package/src/decoder_neon64.cc

@@ -56,6 +56,9 @@ HEDLEY_ALWAYS_INLINE void do_decode_neon(const uint8_t* src, long& len, unsigned
 	if(nextMask == 2)
 		nextMaskMix = vsetq_lane_u8(2, nextMaskMix, 1);
 	uint8x16_t yencOffset = escFirst ? vmakeq_u8(42+64,42,42,42,42,42,42,42,42,42,42,42,42,42,42,42) : vdupq_n_u8(42);
+	
+	decoder_set_nextMask<isRaw>(src, len, nextMask);
+	
 	long i;
 	for(i = -len; i; i += sizeof(uint8x16_t)*4) {
 		uint8x16x4_t data = _vld1q_u8_x4(src+i);
@@ -227,6 +230,7 @@ HEDLEY_ALWAYS_INLINE void do_decode_neon(const uint8_t* src, long& len, unsigned
 							// terminator found
 							// there's probably faster ways to do this, but reverting to scalar code should be good enough
 							len += i;
+							nextMask = decoder_set_nextMask<isRaw>(src+i, mask);
 							break;
 						}
 					}
@@ -275,6 +279,7 @@ HEDLEY_ALWAYS_INLINE void do_decode_neon(const uint8_t* src, long& len, unsigned
 						);
 						if(LIKELIHOOD(0.001, neon_vect_is_nonzero(matchEnd))) {
 							len += i;
+							nextMask = decoder_set_nextMask<isRaw>(src+i, mask);
 							break;
 						}
 					}
@@ -430,17 +435,6 @@ HEDLEY_ALWAYS_INLINE void do_decode_neon(const uint8_t* src, long& len, unsigned
 			yencOffset = vdupq_n_u8(42);
 		}
 	}
-	if(isRaw) {
-		if(len != 0) { // have to gone through at least one loop cycle
-			if(src[i-2] == '\r' && src[i-1] == '\n' && src[i] == '.')
-				nextMask = 1;
-			else if(src[i-1] == '\r' && src[i] == '\n' && src[i+1] == '.')
-				nextMask = 2;
-			else
-				nextMask = 0;
-		}
-	} else
-		nextMask = 0;
 }
 
 void decoder_set_neon_funcs() {
@@ -448,6 +442,7 @@ void decoder_set_neon_funcs() {
 	_do_decode = &do_decode_simd<false, false, sizeof(uint8x16_t)*4, do_decode_neon<false, false> >;
 	_do_decode_raw = &do_decode_simd<true, false, sizeof(uint8x16_t)*4, do_decode_neon<true, false> >;
 	_do_decode_end_raw = &do_decode_simd<true, true, sizeof(uint8x16_t)*4, do_decode_neon<true, true> >;
+	_decode_isa = ISA_LEVEL_NEON;
 }
 #else
 void decoder_set_neon_funcs() {}

package/src/decoder_sse2.cc

@@ -10,6 +10,7 @@ void decoder_set_sse2_funcs() {
 	_do_decode = &do_decode_simd<false, false, sizeof(__m128i)*2, do_decode_sse<false, false, ISA_LEVEL_SSE2> >;
 	_do_decode_raw = &do_decode_simd<true, false, sizeof(__m128i)*2, do_decode_sse<true, false, ISA_LEVEL_SSE2> >;
 	_do_decode_end_raw = &do_decode_simd<true, true, sizeof(__m128i)*2, do_decode_sse<true, true, ISA_LEVEL_SSE2> >;
+	_decode_isa = ISA_LEVEL_SSE2;
 }
 #else
 void decoder_set_sse2_funcs() {}

package/src/decoder_sse_base.h

@@ -145,6 +145,9 @@ HEDLEY_ALWAYS_INLINE void do_decode_sse(const uint8_t* src, long& len, unsigned
 		else
 			lfCompare = _mm_insert_epi16(lfCompare, _nextMask == 1 ? 0x0a2e /*".\n"*/ : 0x2e0a /*"\n."*/, 0);
 	}
+	
+	decoder_set_nextMask<isRaw>(src, len, _nextMask); // set this before the loop because we can't check src after it's been overwritten
+	
 	intptr_t i;
 	for(i = -len; i; i += sizeof(__m128i)*2) {
 		__m128i oDataA = _mm_load_si128((__m128i *)(src+i));
@@ -383,6 +386,7 @@ HEDLEY_ALWAYS_INLINE void do_decode_sse(const uint8_t* src, long& len, unsigned
 							// terminator found
 							// there's probably faster ways to do this, but reverting to scalar code should be good enough
 							len += (long)i;
+							_nextMask = decoder_set_nextMask<isRaw>(src+i, mask);
 							break;
 						}
 					}
@@ -492,6 +496,7 @@ HEDLEY_ALWAYS_INLINE void do_decode_sse(const uint8_t* src, long& len, unsigned
 						
 						if(endFound) {
 							len += (long)i;
+							_nextMask = decoder_set_nextMask<isRaw>(src+i, mask);
 							break;
 						}
 					}
@@ -710,16 +715,5 @@ HEDLEY_ALWAYS_INLINE void do_decode_sse(const uint8_t* src, long& len, unsigned
 		}
 	}
 	_escFirst = (unsigned char)escFirst;
-	if(isRaw) {
-		if(len != 0) { // have to gone through at least one loop cycle
-			if(src[i-2] == '\r' && src[i-1] == '\n' && src[i] == '.')
-				_nextMask = 1;
-			else if(src[i-1] == '\r' && src[i] == '\n' && src[i+1] == '.')
-				_nextMask = 2;
-			else
-				_nextMask = 0;
-		}
-	} else
-		_nextMask = 0;
 }
 #endif

package/src/decoder_ssse3.cc

@@ -9,6 +9,7 @@ void decoder_set_ssse3_funcs() {
 	_do_decode = &do_decode_simd<false, false, sizeof(__m128i)*2, do_decode_sse<false, false, ISA_LEVEL_SSSE3> >;
 	_do_decode_raw = &do_decode_simd<true, false, sizeof(__m128i)*2, do_decode_sse<true, false, ISA_LEVEL_SSSE3> >;
 	_do_decode_end_raw = &do_decode_simd<true, true, sizeof(__m128i)*2, do_decode_sse<true, true, ISA_LEVEL_SSSE3> >;
+	_decode_isa = ISA_LEVEL_SSSE3;
 }
 #else
 void decoder_set_sse2_funcs();

package/src/decoder_vbmi2.cc

@@ -18,6 +18,7 @@ void decoder_set_vbmi2_funcs() {
 	_do_decode = &do_decode_simd<false, false, sizeof(__m256i)*2, do_decode_avx2<false, false, ISA_LEVEL_VBMI2> >;
 	_do_decode_raw = &do_decode_simd<true, false, sizeof(__m256i)*2, do_decode_avx2<true, false, ISA_LEVEL_VBMI2> >;
 	_do_decode_end_raw = &do_decode_simd<true, true, sizeof(__m256i)*2, do_decode_avx2<true, true, ISA_LEVEL_VBMI2> >;
+	_decode_isa = ISA_LEVEL_VBMI2;
 }
 # else
 #  include "decoder_sse_base.h"
@@ -27,6 +28,7 @@ void decoder_set_vbmi2_funcs() {
 	_do_decode = &do_decode_simd<false, false, sizeof(__m128i)*2, do_decode_sse<false, false, ISA_LEVEL_VBMI2> >;
 	_do_decode_raw = &do_decode_simd<true, false, sizeof(__m128i)*2, do_decode_sse<true, false, ISA_LEVEL_VBMI2> >;
 	_do_decode_end_raw = &do_decode_simd<true, true, sizeof(__m128i)*2, do_decode_sse<true, true, ISA_LEVEL_VBMI2> >;
+	_decode_isa = ISA_LEVEL_VBMI2;
 }
 # endif
 #else

package/src/encoder.cc

@@ -122,6 +122,7 @@ size_t do_encode_generic(int line_size, int* colOffset, const unsigned char* HED
 
 extern "C" {
 	size_t (*_do_encode)(int, int*, const unsigned char* HEDLEY_RESTRICT, unsigned char* HEDLEY_RESTRICT, size_t, int) = &do_encode_generic;
+	int _encode_isa = ISA_GENERIC;
 }
 
 void encoder_sse2_init();
@@ -139,12 +140,14 @@ void encoder_rvv_init();
 static inline void encoder_native_init() {
 	_do_encode = &do_encode_simd< do_encode_avx2<ISA_NATIVE> >;
 	encoder_avx2_lut<ISA_NATIVE>();
+	_encode_isa = ISA_NATIVE;
 }
 # else
 #  include "encoder_sse_base.h"
 static inline void encoder_native_init() {
 	_do_encode = &do_encode_simd< do_encode_sse<ISA_NATIVE> >;
 	encoder_sse_lut<ISA_NATIVE>();
+	_encode_isa = ISA_NATIVE;
 }
 # endif
 #endif

package/src/encoder.h

@@ -10,8 +10,12 @@ extern "C" {
 #include "hedley.h"
 
 extern size_t (*_do_encode)(int, int*, const unsigned char* HEDLEY_RESTRICT, unsigned char* HEDLEY_RESTRICT, size_t, int);
+extern int _encode_isa;
 #define do_encode (*_do_encode)
 void encoder_init();
+static inline int encode_isa_level() {
+	return _encode_isa;
+}
 
 
 

package/src/encoder_avx.cc

@@ -6,6 +6,7 @@
 void encoder_avx_init() {
 	_do_encode = &do_encode_simd< do_encode_sse<ISA_LEVEL_SSE4_POPCNT> >;
 	encoder_sse_lut<ISA_LEVEL_SSE4_POPCNT>();
+	_encode_isa = ISA_LEVEL_AVX;
 }
 #else
 void encoder_ssse3_init();

package/src/encoder_avx2.cc

@@ -6,6 +6,7 @@
 void encoder_avx2_init() {
 	_do_encode = &do_encode_simd< do_encode_avx2<ISA_LEVEL_AVX2> >;
 	encoder_avx2_lut<ISA_LEVEL_AVX2>();
+	_encode_isa = ISA_LEVEL_AVX2;
 }
 #else
 void encoder_avx_init();

package/src/encoder_neon.cc

@@ -520,6 +520,7 @@ HEDLEY_ALWAYS_INLINE void do_encode_neon(int line_size, int* colOffset, const ui
 
 void encoder_neon_init() {
 	_do_encode = &do_encode_simd<do_encode_neon>;
+	_encode_isa = ISA_LEVEL_NEON;
 	// generate shuf LUT
 	for(int i=0; i<256; i++) {
 		int k = i;

package/src/encoder_rvv.cc

@@ -213,6 +213,7 @@ HEDLEY_ALWAYS_INLINE void do_encode_rvv(int line_size, int* colOffset, const uin
 
 void encoder_rvv_init() {
 	_do_encode = &do_encode_simd<do_encode_rvv>;
+	_encode_isa = ISA_LEVEL_RVV;
 }
 #else
 void encoder_rvv_init() {}

package/src/encoder_sse2.cc

@@ -6,6 +6,7 @@
 void encoder_sse2_init() {
 	_do_encode = &do_encode_simd< do_encode_sse<ISA_LEVEL_SSE2> >;
 	encoder_sse_lut<ISA_LEVEL_SSE2>();
+	_encode_isa = ISA_LEVEL_SSE2;
 }
 #else
 void encoder_sse2_init() {}

package/src/encoder_ssse3.cc

@@ -8,6 +8,7 @@
 void encoder_ssse3_init() {
 	_do_encode = &do_encode_simd< do_encode_sse<ISA_LEVEL_SSSE3> >;
 	encoder_sse_lut<ISA_LEVEL_SSSE3>();
+	_encode_isa = ISA_LEVEL_SSSE3;
 }
 #else
 void encoder_sse2_init();

package/src/encoder_vbmi2.cc

@@ -14,12 +14,14 @@ const bool encoder_has_avx10 = false;
 void encoder_vbmi2_init() {
 	_do_encode = &do_encode_simd< do_encode_avx2<ISA_LEVEL_VBMI2> >;
 	encoder_avx2_lut<ISA_LEVEL_VBMI2>();
+	_encode_isa = ISA_LEVEL_VBMI2;
 }
 # else
 #  include "encoder_sse_base.h"
 void encoder_vbmi2_init() {
 	_do_encode = &do_encode_simd< do_encode_sse<ISA_LEVEL_VBMI2> >;
 	encoder_sse_lut<ISA_LEVEL_VBMI2>();
+	_encode_isa = ISA_LEVEL_VBMI2;
 }
 # endif
 #else

package/test/testcrc.js

@@ -52,11 +52,11 @@ doTest('Random Continue', 'crc32', ['KZSHZ5EDOVAmDdakZZOrGSUGGKSpCJoWH7M0MHy6ohn
 
 // random tests
 for(var i=1; i<128; i++) {
-	var rand = require('crypto').pseudoRandomBytes(i);
+	var rand = Buffer(require('crypto').randomBytes(i));  // Bun needs explicit Buffer for pseudoRandomBytes
 	doTest('Random Short Buffer', 'crc32', rand);
 }
 for(var i=0; i<32; i++) {
-	var rand = require('crypto').pseudoRandomBytes(100000);
+	var rand = Buffer(require('crypto').randomBytes(100000));
 	doTest('Random Buffer', 'crc32', rand);
 	
 	var split = Math.random()*rand.length;

package/test/testdec.js

@@ -177,7 +177,7 @@ doTest('Extra null issue', toBuffer('2e900a4fb6054c9126171cdc196dc41237bb1b76da9
 
 // random tests
 for(var i=0; i<32; i++) {
-	var rand = require('crypto').pseudoRandomBytes(128*1024);
+	var rand = require('crypto').randomBytes(128*1024);
 	doTest('Random', rand);
 }
 

package/test/testenc.js

@@ -141,7 +141,7 @@ padding.fill(97); // 'a'
 
 // random tests
 for(var i=0; i<32; i++) {
-	var rand = require('crypto').pseudoRandomBytes(4*1024);
+	var rand = require('crypto').randomBytes(4*1024);
 	runLineSizes(function(ls, offs) {
 		doTest('Random [ls='+ls+', offs='+offs+']', [rand, ls, offs]);
 	});