sin_fast_blank 3.1.1 → 4.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f869e6841cba98f0703192b7a3828655a825f886a202954cf0f9a5ca4cdf3d0
-  data.tar.gz: 78b82b2944c4fa1cf20c9ef4b344268545a6c5655a7dbc7b1f207f15d9f89e4d
+  metadata.gz: 715b972c44a78f3a18dcee12c9133c5b38acce03a76fee4031df21d3c5ec8b2f
+  data.tar.gz: bce4b9d3bd8058ab567c620f0cd684f817f4193b20271e481c25a0560954631b
 SHA512:
-  metadata.gz: f3598a5dc110f741cdca4aea40f9627442e91dc32401fb8456b8e731dd20a98e8b2e0d6dfc70275644523cab20e0fee287730571c7b9081977f08dd406dae939
-  data.tar.gz: 26f0d5727b6d5f82ca033e360f745b857dad99654ba111a75267e2054ce600e5584c96c2781e6a82ba62e09650d1652d9673aeec92e1f6a319f2e1a41494bcc1
+  metadata.gz: c8643cd88797cb3d5824536ddfc7f60b4f7bf5718a20a3464b9231720c50e0558fa5234c1f23f0adcb1a8b31664d3a4bb25c3209545619ea0a00e1f5e89408bf
+  data.tar.gz: 14d825f306f16680badaab6c8a1153ef817f889f73ad45169ec6069abf67f25358ed4324c4184c742760cb198cd2066ad32f249fd71e67ddbeafbd755ee2c88f

data/ext/sin_fast_blank/extconf.rb

@@ -2,4 +2,24 @@
 
 require 'mkmf'
 
+old_truffleruby = false
+if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'truffleruby' && defined?(RUBY_ENGINE_VERSION)
+  major_version = RUBY_ENGINE_VERSION.split('.').first.to_i
+  old_truffleruby = major_version < 24
+end
+
+unless old_truffleruby
+  case RbConfig::CONFIG['host_cpu']
+  when /x86_64|i[3-6]86/
+    $CFLAGS << ' -msse2'
+    $CFLAGS << ' -mavx2' if have_header('immintrin.h') && try_compile('#include <immintrin.h>')
+  when /aarch64|arm64/
+    # No special flags needed as NEON is enabled by default on ARM64
+  when /arm/
+    $CFLAGS << ' -mfpu=neon' if have_header('arm_neon.h') && try_compile('#include <arm_neon.h>')
+  end
+end
+
+$CFLAGS << ' -O3 -funroll-loops'
+
 create_makefile 'sin_fast_blank'

data/ext/sin_fast_blank/sin_fast_blank.c

@@ -1,9 +1,29 @@
 #include <ruby.h>
 #include <ruby/encoding.h>
+#include <stdbool.h>
+#ifdef __SSE2__
+#include <emmintrin.h>
+#endif
+#ifdef __AVX2__
+#include <immintrin.h>
+#endif
+#if defined(__ARM_NEON) && defined(__aarch64__)
+#include <arm_neon.h>
+#endif
 
 #define STR_ENC_GET(str) rb_enc_from_index(ENCODING_GET(str))
 
-static inline int is_unicode_blank(unsigned int codepoint) {
+#define ASCII_WS_RANGE_MIN 0x09
+#define ASCII_WS_RANGE_MAX 0x0d
+#define ASCII_WS_SPACE 0x20
+
+static inline bool is_ascii_blank_char(unsigned char c) { return (c >= ASCII_WS_RANGE_MIN && c <= ASCII_WS_RANGE_MAX) || c == ASCII_WS_SPACE; }
+
+static inline bool is_ascii_blank_or_null_char(unsigned char c) {
+  return c == 0x00 || (c >= ASCII_WS_RANGE_MIN && c <= ASCII_WS_RANGE_MAX) || c == ASCII_WS_SPACE;
+}
+
+static inline bool is_unicode_blank(unsigned int codepoint) {
   switch (codepoint) {
     case 0x9:
     case 0xa:
@@ -30,53 +50,245 @@ static inline int is_unicode_blank(unsigned int codepoint) {
     case 0x202f:
     case 0x205f:
     case 0x3000:
-      return 1;
+      return true;
     default:
-      return 0;
+      return false;
   }
 }
 
-static VALUE rb_str_blank(VALUE str) {
-  long len = RSTRING_LEN(str);
-  if (len == 0) {
-    return Qtrue;
+/* Returns true if all blank. On false, sets *non_ascii_pos if non-ASCII found. NULL if non-blank ASCII found. */
+static inline bool scan_ascii_blank(const unsigned char* ptr, size_t len, const unsigned char** non_ascii_pos) {
+  for (size_t i = 0; i < len; i++) {
+    unsigned char c = ptr[i];
+    if (c >= 0x80) {
+      *non_ascii_pos = ptr + i;
+      return false;
+    }
+    if (!is_ascii_blank_char(c)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+static inline bool scan_ascii_blank_or_null(const unsigned char* ptr, size_t len, const unsigned char** non_ascii_pos) {
+  for (size_t i = 0; i < len; i++) {
+    unsigned char c = ptr[i];
+    if (c >= 0x80) {
+      *non_ascii_pos = ptr + i;
+      return false;
+    }
+    if (!is_ascii_blank_or_null_char(c)) {
+      return false;
+    }
   }
+  return true;
+}
 
-  const char *ptr = RSTRING_PTR(str);
-  const char *end = ptr + len;
-  rb_encoding *enc = STR_ENC_GET(str);
+#ifdef __AVX2__
+static bool check_blank_avx2(const unsigned char* ptr, size_t len, const unsigned char** non_ascii_pos) {
+  const __m256i ws_base = _mm256_set1_epi8(ASCII_WS_RANGE_MIN);
+  const __m256i four = _mm256_set1_epi8(ASCII_WS_RANGE_MAX - ASCII_WS_RANGE_MIN);
+  const __m256i space = _mm256_set1_epi8(ASCII_WS_SPACE);
 
-  if (rb_enc_asciicompat(enc)) {
-    for (const unsigned char *p = (const unsigned char *)ptr; p < (const unsigned char *)end; p++) {
-      if (*p >= 0x80) {
-        goto FULL_CHECK;
+  size_t i = 0;
+  for (; i + 31 < len; i += 32) {
+    __m256i chunk = _mm256_loadu_si256((const __m256i*)(ptr + i));
+    __m256i adjusted = _mm256_sub_epi8(chunk, ws_base);
+    __m256i in_range = _mm256_cmpeq_epi8(_mm256_min_epu8(adjusted, four), adjusted);
+    __m256i is_sp = _mm256_cmpeq_epi8(chunk, space);
+    __m256i is_blank = _mm256_or_si256(in_range, is_sp);
+
+    int mask = _mm256_movemask_epi8(is_blank);
+    if (mask != -1) {
+      int first = __builtin_ctz(~mask);
+      unsigned char c = ptr[i + first];
+      if (c >= 0x80) {
+        *non_ascii_pos = ptr + i + first;
       }
+      return false;
+    }
+  }
+
+  return scan_ascii_blank(ptr + i, len - i, non_ascii_pos);
+}
+
+static bool check_ascii_blank_avx2(const unsigned char* ptr, size_t len, const unsigned char** non_ascii_pos) {
+  const __m256i ws_base = _mm256_set1_epi8(ASCII_WS_RANGE_MIN);
+  const __m256i four = _mm256_set1_epi8(ASCII_WS_RANGE_MAX - ASCII_WS_RANGE_MIN);
+  const __m256i space = _mm256_set1_epi8(ASCII_WS_SPACE);
+  const __m256i zero = _mm256_setzero_si256();
+
+  size_t i = 0;
+  for (; i + 31 < len; i += 32) {
+    __m256i chunk = _mm256_loadu_si256((const __m256i*)(ptr + i));
+    __m256i adjusted = _mm256_sub_epi8(chunk, ws_base);
+    __m256i in_range = _mm256_cmpeq_epi8(_mm256_min_epu8(adjusted, four), adjusted);
+    __m256i is_sp = _mm256_cmpeq_epi8(chunk, space);
+    __m256i is_null = _mm256_cmpeq_epi8(chunk, zero);
+    __m256i is_blank = _mm256_or_si256(_mm256_or_si256(in_range, is_sp), is_null);
 
-      switch (*p) {
-        case 0x9:
-        case 0xa:
-        case 0xb:
-        case 0xc:
-        case 0xd:
-        case 0x20:
-          break;
-        default:
-          return Qfalse;
+    int mask = _mm256_movemask_epi8(is_blank);
+    if (mask != -1) {
+      int first = __builtin_ctz(~mask);
+      unsigned char c = ptr[i + first];
+      if (c >= 0x80) {
+        *non_ascii_pos = ptr + i + first;
       }
+      return false;
     }
+  }
 
-    return Qtrue;
+  return scan_ascii_blank_or_null(ptr + i, len - i, non_ascii_pos);
+}
+#endif
+
+#ifdef __SSE2__
+static bool check_blank_sse2(const unsigned char* ptr, size_t len, const unsigned char** non_ascii_pos) {
+  const __m128i ws_base = _mm_set1_epi8(ASCII_WS_RANGE_MIN);
+  const __m128i four = _mm_set1_epi8(ASCII_WS_RANGE_MAX - ASCII_WS_RANGE_MIN);
+  const __m128i space = _mm_set1_epi8(ASCII_WS_SPACE);
+
+  size_t i = 0;
+  for (; i + 15 < len; i += 16) {
+    __m128i chunk = _mm_loadu_si128((const __m128i*)(ptr + i));
+    __m128i adjusted = _mm_sub_epi8(chunk, ws_base);
+    __m128i in_range = _mm_cmpeq_epi8(_mm_min_epu8(adjusted, four), adjusted);
+    __m128i is_sp = _mm_cmpeq_epi8(chunk, space);
+    __m128i is_blank = _mm_or_si128(in_range, is_sp);
+
+    int mask = _mm_movemask_epi8(is_blank);
+    if (mask != 0xFFFF) {
+      int first = __builtin_ctz(~mask & 0xFFFF);
+      unsigned char c = ptr[i + first];
+      if (c >= 0x80) {
+        *non_ascii_pos = ptr + i + first;
+      }
+      return false;
+    }
   }
 
-FULL_CHECK:;
-  while (ptr < end) {
-    int clen;
-    unsigned int codepoint = rb_enc_codepoint_len(ptr, end, &clen, enc);
+  return scan_ascii_blank(ptr + i, len - i, non_ascii_pos);
+}
+
+static bool check_ascii_blank_sse2(const unsigned char* ptr, size_t len, const unsigned char** non_ascii_pos) {
+  const __m128i ws_base = _mm_set1_epi8(ASCII_WS_RANGE_MIN);
+  const __m128i four = _mm_set1_epi8(ASCII_WS_RANGE_MAX - ASCII_WS_RANGE_MIN);
+  const __m128i space = _mm_set1_epi8(ASCII_WS_SPACE);
+  const __m128i zero = _mm_setzero_si128();
+
+  size_t i = 0;
+  for (; i + 15 < len; i += 16) {
+    __m128i chunk = _mm_loadu_si128((const __m128i*)(ptr + i));
+    __m128i adjusted = _mm_sub_epi8(chunk, ws_base);
+    __m128i in_range = _mm_cmpeq_epi8(_mm_min_epu8(adjusted, four), adjusted);
+    __m128i is_sp = _mm_cmpeq_epi8(chunk, space);
+    __m128i is_null = _mm_cmpeq_epi8(chunk, zero);
+    __m128i is_blank = _mm_or_si128(_mm_or_si128(in_range, is_sp), is_null);
+
+    int mask = _mm_movemask_epi8(is_blank);
+    if (mask != 0xFFFF) {
+      int first = __builtin_ctz(~mask & 0xFFFF);
+      unsigned char c = ptr[i + first];
+      if (c >= 0x80) {
+        *non_ascii_pos = ptr + i + first;
+      }
+      return false;
+    }
+  }
+
+  return scan_ascii_blank_or_null(ptr + i, len - i, non_ascii_pos);
+}
+#endif
+
+#if defined(__ARM_NEON) && defined(__aarch64__)
+static bool check_blank_neon(const unsigned char* ptr, size_t len, const unsigned char** non_ascii_pos) {
+  const uint8x16_t ws_base = vdupq_n_u8(ASCII_WS_RANGE_MIN);
+  const uint8x16_t four = vdupq_n_u8(ASCII_WS_RANGE_MAX - ASCII_WS_RANGE_MIN);
+  const uint8x16_t space = vdupq_n_u8(ASCII_WS_SPACE);
+
+  size_t i = 0;
+  for (; i + 15 < len; i += 16) {
+    uint8x16_t chunk = vld1q_u8(ptr + i);
+    uint8x16_t adjusted = vsubq_u8(chunk, ws_base);
+    uint8x16_t in_range = vceqq_u8(vminq_u8(adjusted, four), adjusted);
+    uint8x16_t is_sp = vceqq_u8(chunk, space);
+    uint8x16_t is_blank = vorrq_u8(in_range, is_sp);
+
+    if (vminvq_u8(is_blank) == 0) {
+      if (!scan_ascii_blank(ptr + i, 16, non_ascii_pos)) return false;
+    }
+  }
+
+  return scan_ascii_blank(ptr + i, len - i, non_ascii_pos);
+}
+
+static bool check_ascii_blank_neon(const unsigned char* ptr, size_t len, const unsigned char** non_ascii_pos) {
+  const uint8x16_t ws_base = vdupq_n_u8(ASCII_WS_RANGE_MIN);
+  const uint8x16_t four = vdupq_n_u8(ASCII_WS_RANGE_MAX - ASCII_WS_RANGE_MIN);
+  const uint8x16_t space = vdupq_n_u8(ASCII_WS_SPACE);
+  const uint8x16_t zero = vdupq_n_u8(0);
+
+  size_t i = 0;
+  for (; i + 15 < len; i += 16) {
+    uint8x16_t chunk = vld1q_u8(ptr + i);
+    uint8x16_t adjusted = vsubq_u8(chunk, ws_base);
+    uint8x16_t in_range = vceqq_u8(vminq_u8(adjusted, four), adjusted);
+    uint8x16_t is_sp = vceqq_u8(chunk, space);
+    uint8x16_t is_null = vceqq_u8(chunk, zero);
+    uint8x16_t is_blank = vorrq_u8(vorrq_u8(in_range, is_sp), is_null);
 
-    if (!is_unicode_blank(codepoint)) {
-      return Qfalse;
+    if (vminvq_u8(is_blank) == 0) {
+      if (!scan_ascii_blank_or_null(ptr + i, 16, non_ascii_pos)) return false;
     }
+  }
+
+  return scan_ascii_blank_or_null(ptr + i, len - i, non_ascii_pos);
+}
+#endif
+
+#if !defined(__AVX2__) && !defined(__SSE2__) && !(defined(__ARM_NEON) && defined(__aarch64__))
+static bool check_blank_scalar(const unsigned char* ptr, size_t len, const unsigned char** non_ascii_pos) {
+  return scan_ascii_blank(ptr, len, non_ascii_pos);
+}
+
+static bool check_ascii_blank_scalar(const unsigned char* ptr, size_t len, const unsigned char** non_ascii_pos) {
+  return scan_ascii_blank_or_null(ptr, len, non_ascii_pos);
+}
+#endif
 
+static VALUE rb_str_blank(VALUE str) {
+  long len = RSTRING_LEN(str);
+  if (len == 0) return Qtrue;
+
+  const unsigned char* ptr = (const unsigned char*)RSTRING_PTR(str);
+  const unsigned char* end = ptr + len;
+  rb_encoding* enc = STR_ENC_GET(str);
+
+  if (rb_enc_asciicompat(enc)) {
+    const unsigned char* non_ascii_pos = NULL;
+    bool is_blank = false;
+
+#ifdef __AVX2__
+    is_blank = check_blank_avx2(ptr, (size_t)len, &non_ascii_pos);
+#elif defined(__SSE2__)
+    is_blank = check_blank_sse2(ptr, (size_t)len, &non_ascii_pos);
+#elif defined(__ARM_NEON) && defined(__aarch64__)
+    is_blank = check_blank_neon(ptr, (size_t)len, &non_ascii_pos);
+#else
+    is_blank = check_blank_scalar(ptr, (size_t)len, &non_ascii_pos);
+#endif
+
+    if (is_blank) return Qtrue;
+    if (non_ascii_pos == NULL) return Qfalse;
+
+    ptr = non_ascii_pos;
+  }
+
+  while (ptr < end) {
+    int clen;
+    unsigned int codepoint = rb_enc_codepoint_len((const char*)ptr, (const char*)end, &clen, enc);
+    if (!is_unicode_blank(codepoint)) return Qfalse;
     ptr += clen;
   }
 
@@ -85,39 +297,36 @@ FULL_CHECK:;
 
 static VALUE rb_str_ascii_blank(VALUE str) {
   long len = RSTRING_LEN(str);
-  if (len == 0) {
-    return Qtrue;
-  }
+  if (len == 0) return Qtrue;
 
-  const char *ptr = RSTRING_PTR(str);
-  const char *end = ptr + len;
-  rb_encoding *enc = STR_ENC_GET(str);
+  const unsigned char* ptr = (const unsigned char*)RSTRING_PTR(str);
+  const unsigned char* end = ptr + len;
+  rb_encoding* enc = STR_ENC_GET(str);
 
   if (rb_enc_asciicompat(enc)) {
-    for (; ptr < end; ptr++) {
-      unsigned char c = (unsigned char)*ptr;
+    const unsigned char* non_ascii_pos = NULL;
+    bool is_blank = false;
 
-      if (c >= 0x80) {
-        goto FULL_CHECK;
-      }
+#ifdef __AVX2__
+    is_blank = check_ascii_blank_avx2(ptr, (size_t)len, &non_ascii_pos);
+#elif defined(__SSE2__)
+    is_blank = check_ascii_blank_sse2(ptr, (size_t)len, &non_ascii_pos);
+#elif defined(__ARM_NEON) && defined(__aarch64__)
+    is_blank = check_ascii_blank_neon(ptr, (size_t)len, &non_ascii_pos);
+#else
+    is_blank = check_ascii_blank_scalar(ptr, (size_t)len, &non_ascii_pos);
+#endif
 
-      if (!rb_isspace(c) && c != 0) {
-        return Qfalse;
-      }
-    }
+    if (is_blank) return Qtrue;
+    if (non_ascii_pos == NULL) return Qfalse;
 
-    return Qtrue;
+    ptr = non_ascii_pos;
   }
 
-FULL_CHECK:;
   while (ptr < end) {
     int clen;
-    unsigned int codepoint = rb_enc_codepoint_len(ptr, end, &clen, enc);
-
-    if (codepoint != 0 && !rb_isspace(codepoint)) {
-      return Qfalse;
-    }
-
+    unsigned int codepoint = rb_enc_codepoint_len((const char*)ptr, (const char*)end, &clen, enc);
+    if (codepoint != 0 && !rb_isspace(codepoint)) return Qfalse;
     ptr += clen;
   }
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: sin_fast_blank
 version: !ruby/object:Gem::Version
-  version: 3.1.1
+  version: 4.0.1
 platform: ruby
 authors:
 - Masahiro
 bindir: exe
 cert_chain: []
-date: 2025-03-18 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: Check for blank string faster than FastBlank or ActiveSupport
 email:
@@ -19,15 +19,15 @@ extra_rdoc_files: []
 files:
 - ext/sin_fast_blank/extconf.rb
 - ext/sin_fast_blank/sin_fast_blank.c
-homepage: https://github.com/cadenza-tech/sin_fast_blank/tree/v3.1.1
+homepage: https://github.com/cadenza-tech/sin_fast_blank/tree/v4.0.1
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/cadenza-tech/sin_fast_blank/tree/v3.1.1
-  source_code_uri: https://github.com/cadenza-tech/sin_fast_blank/tree/v3.1.1
-  changelog_uri: https://github.com/cadenza-tech/sin_fast_blank/blob/v3.1.1/CHANGELOG.md
+  homepage_uri: https://github.com/cadenza-tech/sin_fast_blank/tree/v4.0.1
+  source_code_uri: https://github.com/cadenza-tech/sin_fast_blank/tree/v4.0.1
+  changelog_uri: https://github.com/cadenza-tech/sin_fast_blank/blob/v4.0.1/CHANGELOG.md
   bug_tracker_uri: https://github.com/cadenza-tech/sin_fast_blank/issues
-  documentation_uri: https://rubydoc.info/gems/sin_fast_blank/3.1.1
+  documentation_uri: https://rubydoc.info/gems/sin_fast_blank/4.0.1
   funding_uri: https://patreon.com/CadenzaTech
   rubygems_mfa_required: 'true'
   required_jruby_version: ">= 9.3.0.0"
@@ -47,7 +47,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Check for blank string faster than FastBlank or ActiveSupport
 test_files: []