stride-align 0.6.0

data/ext/stride_align/backend_lasx.cpp

@@ -0,0 +1,2 @@
+#define STRIDE_ALIGN_RUBY_TARGET_LASX 1
+#include "backend_impl.hpp"

data/ext/stride_align/backend_lsx.cpp

@@ -0,0 +1,2 @@
+#define STRIDE_ALIGN_RUBY_TARGET_LSX 1
+#include "backend_impl.hpp"

data/ext/stride_align/backend_neon.cpp

@@ -0,0 +1,2 @@
+#define STRIDE_ALIGN_RUBY_TARGET_NEON 1
+#include "backend_impl.hpp"

data/ext/stride_align/backend_rvv.cpp

@@ -0,0 +1,2 @@
+#define STRIDE_ALIGN_RUBY_TARGET_RVV 1
+#include "backend_impl.hpp"

data/ext/stride_align/backend_sse41.cpp

@@ -0,0 +1,2 @@
+#define STRIDE_ALIGN_RUBY_TARGET_SSE41 1
+#include "backend_impl.hpp"

data/ext/stride_align/backend_sve.cpp

@@ -0,0 +1,2 @@
+#define STRIDE_ALIGN_RUBY_TARGET_SVE 1
+#include "backend_impl.hpp"

data/ext/stride_align/backend_sve2.cpp

@@ -0,0 +1,2 @@
+#define STRIDE_ALIGN_RUBY_TARGET_SVE2 1
+#include "backend_impl.hpp"

data/ext/stride_align/backend_vsx.cpp

@@ -0,0 +1,2 @@
+#define STRIDE_ALIGN_RUBY_TARGET_VSX 1
+#include "backend_impl.hpp"

data/ext/stride_align/beider_morse_impl.cpp

@@ -0,0 +1,5 @@
+#if __has_include("vendor/beider_morse_impl.cpp")
+#include "vendor/beider_morse_impl.cpp"
+#else
+#include "../../../../src/cpp/beider_morse_impl.cpp"
+#endif

data/ext/stride_align/cpu_detect.cpp

@@ -0,0 +1,172 @@
+#include "cpu_detect.hpp"
+
+#include <string>
+#include <vector>
+
+#if defined(__linux__) && \
+    (defined(__aarch64__) || defined(__loongarch__) || \
+     defined(__powerpc64__) || defined(__ppc64__) || defined(__riscv))
+#include <sys/auxv.h>
+#endif
+
+#if defined(__linux__) && defined(__aarch64__)
+#include <asm/hwcap.h>
+#include <sys/prctl.h>
+#endif
+
+#if defined(__linux__) && defined(__loongarch__)
+#include <asm/hwcap.h>
+#endif
+
+#if defined(__linux__) && \
+    (defined(__powerpc64__) || defined(__ppc64__) || defined(__PPC64__))
+#include <asm/cputable.h>
+#endif
+
+#if defined(__linux__) && defined(__riscv)
+#include <asm/hwcap.h>
+#endif
+
+namespace {
+
+[[maybe_unused]] bool supports_sse41() noexcept {
+#if (defined(__x86_64__) || defined(__i386__)) && \
+    (defined(__GNUC__) || defined(__clang__))
+  __builtin_cpu_init();
+  return __builtin_cpu_supports("sse4.1") != 0;
+#else
+  return false;
+#endif
+}
+
+[[maybe_unused]] bool supports_x86_64_v3() noexcept {
+#if (defined(__x86_64__) || defined(__i386__)) && \
+    (defined(__GNUC__) || defined(__clang__))
+  __builtin_cpu_init();
+  return __builtin_cpu_supports("avx2") != 0 &&
+      __builtin_cpu_supports("bmi") != 0 &&
+      __builtin_cpu_supports("bmi2") != 0 &&
+      __builtin_cpu_supports("f16c") != 0 &&
+      __builtin_cpu_supports("fma") != 0 &&
+      __builtin_cpu_supports("lzcnt") != 0 &&
+      __builtin_cpu_supports("movbe") != 0;
+#else
+  return false;
+#endif
+}
+
+[[maybe_unused]] bool supports_avx512bwvl() noexcept {
+#if (defined(__x86_64__) || defined(__i386__)) && \
+    (defined(__GNUC__) || defined(__clang__))
+  __builtin_cpu_init();
+  return supports_x86_64_v3() &&
+      __builtin_cpu_supports("avx512f") != 0 &&
+      __builtin_cpu_supports("avx512bw") != 0 &&
+      __builtin_cpu_supports("avx512cd") != 0 &&
+      __builtin_cpu_supports("avx512vl") != 0 &&
+      __builtin_cpu_supports("avx512dq") != 0;
+#else
+  return false;
+#endif
+}
+
+[[maybe_unused]] bool supports_neon() noexcept {
+#if defined(__APPLE__) && defined(__aarch64__)
+  return true;
+#elif defined(__linux__) && defined(__aarch64__)
+  return (getauxval(AT_HWCAP) & HWCAP_ASIMD) != 0;
+#else
+  return false;
+#endif
+}
+
+[[maybe_unused]] bool supports_sve() noexcept {
+#if defined(__linux__) && defined(__aarch64__) && defined(HWCAP_SVE) && \
+    defined(PR_SVE_GET_VL) && defined(PR_SVE_VL_LEN_MASK)
+  if ((getauxval(AT_HWCAP) & HWCAP_SVE) == 0) return false;
+  const int vector_length = prctl(PR_SVE_GET_VL);
+  return vector_length >= 0 &&
+      (vector_length & PR_SVE_VL_LEN_MASK) == 16;
+#else
+  return false;
+#endif
+}
+
+[[maybe_unused]] bool supports_sve2() noexcept {
+#if defined(__linux__) && defined(__aarch64__) && defined(HWCAP2_SVE2)
+  return supports_sve() && (getauxval(AT_HWCAP2) & HWCAP2_SVE2) != 0;
+#else
+  return false;
+#endif
+}
+
+[[maybe_unused]] bool supports_lsx() noexcept {
+#if defined(__linux__) && defined(__loongarch__)
+  return (getauxval(AT_HWCAP) & HWCAP_LOONGARCH_LSX) != 0;
+#else
+  return false;
+#endif
+}
+
+[[maybe_unused]] bool supports_lasx() noexcept {
+#if defined(__linux__) && defined(__loongarch__)
+  return (getauxval(AT_HWCAP) & HWCAP_LOONGARCH_LASX) != 0;
+#else
+  return false;
+#endif
+}
+
+[[maybe_unused]] bool supports_vsx() noexcept {
+#if defined(__linux__) && \
+    (defined(__powerpc64__) || defined(__ppc64__) || defined(__PPC64__))
+  return (getauxval(AT_HWCAP) & PPC_FEATURE_HAS_VSX) != 0;
+#else
+  return false;
+#endif
+}
+
+[[maybe_unused]] bool supports_rvv() noexcept {
+#if defined(__linux__) && defined(__riscv) && defined(COMPAT_HWCAP_ISA_V)
+  return (getauxval(AT_HWCAP) & COMPAT_HWCAP_ISA_V) != 0;
+#else
+  return false;
+#endif
+}
+
+}  // namespace
+
+std::vector<std::string> stride_align_ruby_backend_candidates() {
+  std::vector<std::string> names;
+#if defined(STRIDE_ALIGN_RUBY_HAVE_AVX512BWVL)
+  if (supports_avx512bwvl()) names.emplace_back("avx512bwvl");
+#endif
+#if defined(STRIDE_ALIGN_RUBY_HAVE_AVX2)
+  if (supports_x86_64_v3()) names.emplace_back("avx2");
+#endif
+#if defined(STRIDE_ALIGN_RUBY_HAVE_SSE41)
+  if (supports_sse41()) names.emplace_back("sse41");
+#endif
+#if defined(STRIDE_ALIGN_RUBY_HAVE_SVE2)
+  if (supports_sve2()) names.emplace_back("sve2");
+#endif
+#if defined(STRIDE_ALIGN_RUBY_HAVE_SVE)
+  if (supports_sve()) names.emplace_back("sve");
+#endif
+#if defined(STRIDE_ALIGN_RUBY_HAVE_NEON)
+  if (supports_neon()) names.emplace_back("neon");
+#endif
+#if defined(STRIDE_ALIGN_RUBY_HAVE_LASX)
+  if (supports_lasx()) names.emplace_back("lasx");
+#endif
+#if defined(STRIDE_ALIGN_RUBY_HAVE_LSX)
+  if (supports_lsx()) names.emplace_back("lsx");
+#endif
+#if defined(STRIDE_ALIGN_RUBY_HAVE_VSX)
+  if (supports_vsx()) names.emplace_back("vsx");
+#endif
+#if defined(STRIDE_ALIGN_RUBY_HAVE_RVV)
+  if (supports_rvv()) names.emplace_back("rvv");
+#endif
+  names.emplace_back("generic");
+  return names;
+}

data/ext/stride_align/cpu_detect.hpp

@@ -0,0 +1,6 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+std::vector<std::string> stride_align_ruby_backend_candidates();

data/ext/stride_align/extconf.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "mkmf"
+require "rbconfig"
+require "shellwords"
+
+extension_root = File.expand_path(__dir__)
+repository_root = File.expand_path("../../../../", extension_root)
+vendored_include = File.join(extension_root, "vendor")
+include_root = if File.directory?(File.join(vendored_include, "stride_align"))
+                 vendored_include
+               else
+                 File.join(repository_root, "include")
+               end
+
+abort "stride-align C++ headers were not found" unless File.file?(
+  File.join(include_root, "stride_align", "core.hpp")
+)
+
+$INCFLAGS = "-I#{Shellwords.escape(include_root)} #{$INCFLAGS}"
+$CXXFLAGS = "#{$CXXFLAGS} -std=c++20 -O3 -Wall -Wextra -Wpedantic -Wno-register"
+
+host_cpu = RbConfig::CONFIG.fetch("host_cpu", "").downcase
+host_os = RbConfig::CONFIG.fetch("host_os", "").downcase
+
+def supports_flags?(flags)
+  try_compile("int main() { return 0; }", flags)
+end
+
+base_flags = ""
+profiles = {}
+
+case host_cpu
+when /x86_64|amd64/
+  base_flags = "-march=x86-64 -mtune=generic -msse2 -mno-avx -mno-avx2 -mno-avx512f"
+  candidates = {
+    "sse41" => "-march=x86-64 -mtune=generic -msse4.1 -mno-avx -mno-avx2 -mno-avx512f",
+    # The generic flags are part of CXXFLAGS and explicitly disable AVX. GCC
+    # preserves those -mno-* choices across a later -march, so re-enable the
+    # profile features here instead of relying on -march alone.
+    "avx2" => "-march=x86-64-v3 -mtune=generic -mavx -mavx2",
+    "avx512bwvl" => "-march=x86-64-v4 -mtune=generic -mavx -mavx2 -mavx512f -mavx512bw -mavx512cd -mavx512vl -mavx512dq"
+  }
+  candidates.each { |name, flags| profiles[name] = flags if supports_flags?(flags) }
+when /aarch64|arm64/
+  neon_flags = host_os.include?("darwin") ? "-mcpu=apple-m1" : "-march=armv8-a+simd -mtune=generic"
+  profiles["neon"] = neon_flags if supports_flags?(neon_flags)
+  if host_os.include?("linux")
+    sve_flags = "-march=armv8.2-a+sve -msve-vector-bits=128 -mtune=generic"
+    sve2_flags = "-march=armv9-a+sve2 -msve-vector-bits=128 -mtune=generic"
+    profiles["sve"] = sve_flags if supports_flags?(sve_flags)
+    profiles["sve2"] = sve2_flags if supports_flags?(sve2_flags)
+  end
+when /loongarch64/
+  base_flags = "-march=loongarch64 -mtune=generic -mno-lsx -mno-lasx"
+  $LDFLAGS = "#{$LDFLAGS} -static-libstdc++ -static-libgcc" if host_os.include?("linux")
+  candidates = {
+    "lsx" => "-march=la464 -mtune=la464 -mlsx -mno-lasx",
+    "lasx" => "-march=la464 -mtune=la464 -mlsx -mlasx"
+  }
+  candidates.each { |name, flags| profiles[name] = flags if supports_flags?(flags) }
+when /ppc64|powerpc64/
+  $LDFLAGS = "#{$LDFLAGS} -static-libstdc++ -static-libgcc" if host_os.include?("linux")
+  flags = "-mcpu=power8 -mtune=power8 -mvsx"
+  profiles["vsx"] = flags if supports_flags?(flags)
+when /riscv64/
+  base_flags = "-march=rv64gc -mabi=lp64d"
+  flags = "-march=rv64gcv -mabi=lp64d"
+  profiles["rvv"] = flags if supports_flags?(flags)
+end
+
+have_defines = profiles.keys.map do |name|
+  "-DSTRIDE_ALIGN_RUBY_HAVE_#{name.upcase}=1"
+end
+
+$CPPFLAGS = "#{$CPPFLAGS} #{have_defines.join(' ')}"
+$CXXFLAGS = "#{$CXXFLAGS} #{base_flags}" unless base_flags.empty?
+$srcs = %w[backend_generic.cpp cpu_detect.cpp beider_morse_impl.cpp]
+$objs = $srcs.map { |source| source.sub(/\.cpp\z/, ".o") }
+
+create_makefile("stride_align/_generic")
+
+dlext = RbConfig::CONFIG.fetch("DLEXT")
+backend_targets = profiles.keys.map { |name| "_#{name}.#{dlext}" }
+
+File.open("Makefile", "a") do |makefile|
+  makefile.puts
+  makefile.puts "STRIDE_ALIGN_RUBY_BACKENDS = #{profiles.keys.join(' ')}"
+  makefile.puts "STRIDE_ALIGN_RUBY_BACKEND_TARGETS = #{backend_targets.join(' ')}"
+  makefile.puts "CLEANOBJS += $(STRIDE_ALIGN_RUBY_BACKEND_TARGETS)"
+  makefile.puts "all: $(STRIDE_ALIGN_RUBY_BACKEND_TARGETS)"
+  makefile.puts
+
+  profiles.each do |name, flags|
+    object = "backend_#{name}.o"
+    target = "_#{name}.#{dlext}"
+    makefile.puts "#{object}: backend_#{name}.cpp backend_impl.hpp target_profile.hpp"
+    makefile.puts "\t$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) #{flags} -c $< -o $@"
+    makefile.puts
+    makefile.puts "#{target}: #{object}"
+    makefile.puts "\t$(LDSHAREDXX) $(DLDFLAGS) $(ARCH_FLAG) $(LDFLAGS) -o $@ $^ $(LOCAL_LIBS) $(LIBS)"
+    makefile.puts
+  end
+
+  makefile.puts "install-so: install-stride-align-backends"
+  makefile.puts "install-stride-align-backends: $(STRIDE_ALIGN_RUBY_BACKEND_TARGETS)"
+  makefile.puts "\t$(MAKEDIRS) $(DESTDIR)$(sitearchdir)/stride_align"
+  unless backend_targets.empty?
+    makefile.puts "\t$(INSTALL_PROG) $(STRIDE_ALIGN_RUBY_BACKEND_TARGETS) $(DESTDIR)$(sitearchdir)/stride_align"
+  end
+  makefile.puts ".PHONY: install-stride-align-backends"
+end
+
+puts "stride-align Ruby backends: #{profiles.empty? ? 'generic only' : profiles.keys.join(', ')}"

data/ext/stride_align/target_profile.hpp

@@ -0,0 +1,82 @@
+#pragma once
+
+// Every Ruby native backend is a separate importable extension compiled for
+// exactly one ISA.  Keep the selected profile and compiler feature macros in
+// lock-step so a mislabeled binary fails while the gem is being built rather
+// than crashing on a user's machine.
+
+#if (defined(STRIDE_ALIGN_RUBY_TARGET_GENERIC) + \
+     defined(STRIDE_ALIGN_RUBY_TARGET_SSE41) + \
+     defined(STRIDE_ALIGN_RUBY_TARGET_AVX2) + \
+     defined(STRIDE_ALIGN_RUBY_TARGET_AVX512BWVL) + \
+     defined(STRIDE_ALIGN_RUBY_TARGET_NEON) + \
+     defined(STRIDE_ALIGN_RUBY_TARGET_SVE) + \
+     defined(STRIDE_ALIGN_RUBY_TARGET_SVE2) + \
+     defined(STRIDE_ALIGN_RUBY_TARGET_LSX) + \
+     defined(STRIDE_ALIGN_RUBY_TARGET_LASX) + \
+     defined(STRIDE_ALIGN_RUBY_TARGET_VSX) + \
+     defined(STRIDE_ALIGN_RUBY_TARGET_RVV)) != 1
+#error "Exactly one Ruby backend target must be selected"
+#endif
+
+#if defined(STRIDE_ALIGN_RUBY_TARGET_GENERIC) && \
+    (defined(__x86_64__) || defined(__i386__)) && \
+    (defined(__AVX__) || defined(__AVX2__) || defined(__AVX512F__))
+#error "The generic x86 Ruby backend unexpectedly enables AVX"
+#endif
+
+#if defined(STRIDE_ALIGN_RUBY_TARGET_GENERIC) && defined(__loongarch__) && \
+    (defined(__loongarch_sx) || defined(__loongarch_asx))
+#error "The generic LoongArch Ruby backend unexpectedly enables LSX or LASX"
+#endif
+
+#if defined(STRIDE_ALIGN_RUBY_TARGET_SSE41) && \
+    (!defined(__SSE4_1__) || defined(__AVX__))
+#error "The SSE4.1 Ruby backend must select SSE4.1 without AVX"
+#endif
+
+#if defined(STRIDE_ALIGN_RUBY_TARGET_AVX2) && \
+    (!defined(__AVX2__) || !defined(__BMI__) || !defined(__BMI2__) || \
+     !defined(__F16C__) || !defined(__FMA__) || !defined(__LZCNT__) || \
+     !defined(__MOVBE__) || defined(__AVX512F__))
+#error "The AVX2 Ruby backend must select the x86-64-v3 feature set"
+#endif
+
+#if defined(STRIDE_ALIGN_RUBY_TARGET_AVX512BWVL) && \
+    (!defined(__AVX512F__) || !defined(__AVX512BW__) || \
+     !defined(__AVX512CD__) || !defined(__AVX512VL__) || \
+     !defined(__AVX512DQ__))
+#error "The AVX-512 Ruby backend requires the x86-64-v4 feature set"
+#endif
+
+#if defined(STRIDE_ALIGN_RUBY_TARGET_NEON) && \
+    !defined(__ARM_NEON) && !defined(__ARM_NEON__)
+#error "The NEON Ruby backend did not select NEON"
+#endif
+
+#if defined(STRIDE_ALIGN_RUBY_TARGET_SVE) && \
+    (!defined(__ARM_FEATURE_SVE) || defined(__ARM_FEATURE_SVE2))
+#error "The SVE Ruby backend must select SVE without SVE2"
+#endif
+
+#if defined(STRIDE_ALIGN_RUBY_TARGET_SVE2) && !defined(__ARM_FEATURE_SVE2)
+#error "The SVE2 Ruby backend did not select SVE2"
+#endif
+
+#if defined(STRIDE_ALIGN_RUBY_TARGET_LSX) && \
+    (!defined(__loongarch_sx) || defined(__loongarch_asx))
+#error "The LSX Ruby backend must select LSX without LASX"
+#endif
+
+#if defined(STRIDE_ALIGN_RUBY_TARGET_LASX) && \
+    (!defined(__loongarch_sx) || !defined(__loongarch_asx))
+#error "The LASX Ruby backend did not select LASX"
+#endif
+
+#if defined(STRIDE_ALIGN_RUBY_TARGET_VSX) && !defined(__VSX__)
+#error "The VSX Ruby backend did not select VSX"
+#endif
+
+#if defined(STRIDE_ALIGN_RUBY_TARGET_RVV) && !defined(__riscv_vector)
+#error "The RVV Ruby backend did not select the vector extension"
+#endif