sin_fast_blank 3.1.1 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f869e6841cba98f0703192b7a3828655a825f886a202954cf0f9a5ca4cdf3d0
-  data.tar.gz: 78b82b2944c4fa1cf20c9ef4b344268545a6c5655a7dbc7b1f207f15d9f89e4d
+  metadata.gz: bcfe1a1adde100fe8c917a5ed228c8d768db39889057af0bf416e00da3d1ad79
+  data.tar.gz: 96d8c90536ebf9af9ecd318a7f55bffcf25891e97be4f0f729479171cd2da1a3
 SHA512:
-  metadata.gz: f3598a5dc110f741cdca4aea40f9627442e91dc32401fb8456b8e731dd20a98e8b2e0d6dfc70275644523cab20e0fee287730571c7b9081977f08dd406dae939
-  data.tar.gz: 26f0d5727b6d5f82ca033e360f745b857dad99654ba111a75267e2054ce600e5584c96c2781e6a82ba62e09650d1652d9673aeec92e1f6a319f2e1a41494bcc1
+  metadata.gz: c9f184a85aeea502010499f881f16b2aa21c199f2f84dbe57b8e93641a31603a5a1a27afadcbbd805dc49e25a1361bfa91af1ef71e25ae30e0caf2a73d06bd67
+  data.tar.gz: 9fb4fe47265d8c23b5f093dc9d0ce05f5b5d81b501a7e70466cbaec7389719f18999a46981ed96c027580051ae06fd151f734bdf3f5d6ed0a9ee43bf8f010b8d

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,8 +1,34 @@
 #include <ruby.h>
 #include <ruby/encoding.h>
+#include <stdbool.h>
+#ifdef __SSE2__
+  #include <emmintrin.h>
+#endif
+#ifdef __AVX2__
+  #include <immintrin.h>
+#endif
+#ifdef __ARM_NEON
+  #include <arm_neon.h>
+#endif
 
 #define STR_ENC_GET(str) rb_enc_from_index(ENCODING_GET(str))
 
+#define ASCII_BLANK_TAB 0x09
+#define ASCII_BLANK_LF 0x0a
+#define ASCII_BLANK_VT 0x0b
+#define ASCII_BLANK_FF 0x0c
+#define ASCII_BLANK_CR 0x0d
+#define ASCII_BLANK_SPACE 0x20
+
+static inline bool is_ascii_blank_char(unsigned char c) {
+  return c == ASCII_BLANK_SPACE ||
+         c == ASCII_BLANK_TAB ||
+         c == ASCII_BLANK_LF ||
+         c == ASCII_BLANK_VT ||
+         c == ASCII_BLANK_FF ||
+         c == ASCII_BLANK_CR;
+}
+
 static inline int is_unicode_blank(unsigned int codepoint) {
   switch (codepoint) {
     case 0x9:
@@ -36,42 +62,264 @@ static inline int is_unicode_blank(unsigned int codepoint) {
   }
 }
 
+#ifdef __AVX2__
+static bool check_blank_avx2(const unsigned char *ptr, size_t len, const unsigned char **non_ascii_pos) {
+  const __m256i ascii_mask = _mm256_set1_epi8(0x80);
+  const __m256i space = _mm256_set1_epi8(ASCII_BLANK_SPACE);
+  const __m256i tab = _mm256_set1_epi8(ASCII_BLANK_TAB);
+  const __m256i lf = _mm256_set1_epi8(ASCII_BLANK_LF);
+  const __m256i vt = _mm256_set1_epi8(ASCII_BLANK_VT);
+  const __m256i ff = _mm256_set1_epi8(ASCII_BLANK_FF);
+  const __m256i cr = _mm256_set1_epi8(ASCII_BLANK_CR);
+
+  size_t i = 0;
+
+  for (; i + 31 < len; i += 32) {
+    __m256i chunk = _mm256_loadu_si256((const __m256i *)(ptr + i));
+
+    __m256i non_ascii = _mm256_and_si256(chunk, ascii_mask);
+    if (!_mm256_testz_si256(non_ascii, non_ascii)) {
+      for (size_t j = 0; j < 32; j++) {
+        if (ptr[i + j] >= 0x80) {
+          *non_ascii_pos = ptr + i + j;
+          return false;
+        }
+      }
+    }
+
+    __m256i is_space = _mm256_cmpeq_epi8(chunk, space);
+    __m256i is_tab = _mm256_cmpeq_epi8(chunk, tab);
+    __m256i is_lf = _mm256_cmpeq_epi8(chunk, lf);
+    __m256i is_vt = _mm256_cmpeq_epi8(chunk, vt);
+    __m256i is_ff = _mm256_cmpeq_epi8(chunk, ff);
+    __m256i is_cr = _mm256_cmpeq_epi8(chunk, cr);
+
+    __m256i is_blank = _mm256_or_si256(is_space, is_tab);
+    is_blank = _mm256_or_si256(is_blank, is_lf);
+    is_blank = _mm256_or_si256(is_blank, is_vt);
+    is_blank = _mm256_or_si256(is_blank, is_ff);
+    is_blank = _mm256_or_si256(is_blank, is_cr);
+
+    if (_mm256_movemask_epi8(is_blank) != -1) {
+      for (size_t j = 0; j < 32; j++) {
+        unsigned char c = ptr[i + j];
+        if (c >= 0x80) {
+          *non_ascii_pos = ptr + i + j;
+          return false;
+        }
+        if (!is_ascii_blank_char(c)) {
+          return false;
+        }
+      }
+    }
+  }
+
+  for (; 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;
+}
+#endif
+
+#ifdef __SSE2__
+static bool check_blank_sse2(const unsigned char *ptr, size_t len, const unsigned char **non_ascii_pos) {
+  const __m128i ascii_mask = _mm_set1_epi8(0x80);
+  const __m128i space = _mm_set1_epi8(ASCII_BLANK_SPACE);
+  const __m128i tab = _mm_set1_epi8(ASCII_BLANK_TAB);
+  const __m128i lf = _mm_set1_epi8(ASCII_BLANK_LF);
+  const __m128i vt = _mm_set1_epi8(ASCII_BLANK_VT);
+  const __m128i ff = _mm_set1_epi8(ASCII_BLANK_FF);
+  const __m128i cr = _mm_set1_epi8(ASCII_BLANK_CR);
+
+  size_t i = 0;
+
+  for (; i + 15 < len; i += 16) {
+    __m128i chunk = _mm_loadu_si128((const __m128i *)(ptr + i));
+
+    __m128i non_ascii = _mm_and_si128(chunk, ascii_mask);
+    if (_mm_movemask_epi8(non_ascii) != 0) {
+      for (size_t j = 0; j < 16; j++) {
+        if (ptr[i + j] >= 0x80) {
+          *non_ascii_pos = ptr + i + j;
+          return false;
+        }
+      }
+    }
+
+    __m128i is_space = _mm_cmpeq_epi8(chunk, space);
+    __m128i is_tab = _mm_cmpeq_epi8(chunk, tab);
+    __m128i is_lf = _mm_cmpeq_epi8(chunk, lf);
+    __m128i is_vt = _mm_cmpeq_epi8(chunk, vt);
+    __m128i is_ff = _mm_cmpeq_epi8(chunk, ff);
+    __m128i is_cr = _mm_cmpeq_epi8(chunk, cr);
+
+    __m128i is_blank = _mm_or_si128(is_space, is_tab);
+    is_blank = _mm_or_si128(is_blank, is_lf);
+    is_blank = _mm_or_si128(is_blank, is_vt);
+    is_blank = _mm_or_si128(is_blank, is_ff);
+    is_blank = _mm_or_si128(is_blank, is_cr);
+
+    if (_mm_movemask_epi8(is_blank) != 0xFFFF) {
+      for (size_t j = 0; j < 16; j++) {
+        unsigned char c = ptr[i + j];
+        if (c >= 0x80) {
+          *non_ascii_pos = ptr + i + j;
+          return false;
+        }
+        if (!is_ascii_blank_char(c)) {
+          return false;
+        }
+      }
+    }
+  }
+
+  for (; 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;
+}
+#endif
+
+#ifdef __ARM_NEON
+static bool check_blank_neon(const unsigned char *ptr, size_t len, const unsigned char **non_ascii_pos) {
+  const uint8x16_t ascii_mask = vdupq_n_u8(0x80);
+  const uint8x16_t space = vdupq_n_u8(ASCII_BLANK_SPACE);
+  const uint8x16_t tab = vdupq_n_u8(ASCII_BLANK_TAB);
+  const uint8x16_t lf = vdupq_n_u8(ASCII_BLANK_LF);
+  const uint8x16_t vt = vdupq_n_u8(ASCII_BLANK_VT);
+  const uint8x16_t ff = vdupq_n_u8(ASCII_BLANK_FF);
+  const uint8x16_t cr = vdupq_n_u8(ASCII_BLANK_CR);
+
+  size_t i = 0;
+
+  for (; i + 15 < len; i += 16) {
+    uint8x16_t chunk = vld1q_u8(ptr + i);
+
+    uint8x16_t non_ascii = vandq_u8(chunk, ascii_mask);
+    uint8x16_t has_non_ascii = vceqq_u8(non_ascii, ascii_mask);
+
+    if (vmaxvq_u8(has_non_ascii) != 0) {
+      for (size_t j = 0; j < 16; j++) {
+        if (ptr[i + j] >= 0x80) {
+          *non_ascii_pos = ptr + i + j;
+          return false;
+        }
+      }
+    }
+
+    uint8x16_t is_space = vceqq_u8(chunk, space);
+    uint8x16_t is_tab = vceqq_u8(chunk, tab);
+    uint8x16_t is_lf = vceqq_u8(chunk, lf);
+    uint8x16_t is_vt = vceqq_u8(chunk, vt);
+    uint8x16_t is_ff = vceqq_u8(chunk, ff);
+    uint8x16_t is_cr = vceqq_u8(chunk, cr);
+
+    uint8x16_t is_blank = vorrq_u8(is_space, is_tab);
+    is_blank = vorrq_u8(is_blank, is_lf);
+    is_blank = vorrq_u8(is_blank, is_vt);
+    is_blank = vorrq_u8(is_blank, is_ff);
+    is_blank = vorrq_u8(is_blank, is_cr);
+
+    if (vminvq_u8(is_blank) == 0) {
+      for (size_t j = 0; j < 16; j++) {
+        unsigned char c = ptr[i + j];
+        if (c >= 0x80) {
+          *non_ascii_pos = ptr + i + j;
+          return false;
+        }
+        if (!is_ascii_blank_char(c)) {
+          return false;
+        }
+      }
+    }
+  }
+
+  for (; 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;
+}
+#endif
+
+static bool check_blank_scalar(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 VALUE rb_str_blank(VALUE str) {
   long len = RSTRING_LEN(str);
   if (len == 0) {
     return Qtrue;
   }
 
-  const char *ptr = RSTRING_PTR(str);
-  const char *end = ptr + len;
+  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 (const unsigned char *p = (const unsigned char *)ptr; p < (const unsigned char *)end; p++) {
-      if (*p >= 0x80) {
-        goto FULL_CHECK;
-      }
+    const unsigned char *non_ascii_pos = NULL;
+    bool is_blank = false;
 
-      switch (*p) {
-        case 0x9:
-        case 0xa:
-        case 0xb:
-        case 0xc:
-        case 0xd:
-        case 0x20:
-          break;
-        default:
-          return Qfalse;
-      }
+#ifdef __AVX2__
+    is_blank = check_blank_avx2(ptr, len, &non_ascii_pos);
+#elif defined(__SSE2__)
+    is_blank = check_blank_sse2(ptr, len, &non_ascii_pos);
+#elif defined(__ARM_NEON)
+    is_blank = check_blank_neon(ptr, len, &non_ascii_pos);
+#else
+    is_blank = check_blank_scalar(ptr, len, &non_ascii_pos);
+#endif
+
+    if (is_blank) {
+      return Qtrue;
     }
 
-    return Qtrue;
+    if (non_ascii_pos == NULL) {
+      return Qfalse;
+    }
+
+    ptr = (const unsigned char *)non_ascii_pos;
   }
 
-FULL_CHECK:;
-  while (ptr < end) {
+  while ((const char *)ptr < (const char *)end) {
     int clen;
-    unsigned int codepoint = rb_enc_codepoint_len(ptr, end, &clen, enc);
+    unsigned int codepoint = rb_enc_codepoint_len((const char *)ptr, (const char *)end, &clen, enc);
 
     if (!is_unicode_blank(codepoint)) {
       return Qfalse;

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.0
 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.0
 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.0
+  source_code_uri: https://github.com/cadenza-tech/sin_fast_blank/tree/v4.0.0
+  changelog_uri: https://github.com/cadenza-tech/sin_fast_blank/blob/v4.0.0/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.0
   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: []