Make SLEEF the default for functions on macos (Accelerate does not provide precision enough)

Author: FrancescAlted

README_DEVELOPERS.md

@@ -92,7 +92,7 @@ The main [README.md](README.md) keeps the simplest supported build path. This se
 - On Emscripten, setting `MINIEXPR_ENABLE_TCC_JIT=ON` enables wasm32 JIT support automatically.
 - Setting `MINIEXPR_ENABLE_TCC_JIT=OFF` disables TCC-based JIT backends; on Linux/macOS, the separate `# me:compiler=cc` runtime path may still be available.
 - `MINIEXPR_USE_SLEEF=ON` fetches SLEEF and enables SIMD math acceleration; set it to `OFF` to build without SLEEF.
-- `MINIEXPR_USE_ACCELERATE=ON` enables the macOS Accelerate/vForce backend; in `auto` mode on macOS it is preferred by default, and unsupported functions still fall back to scalar kernels.
+- `MINIEXPR_USE_ACCELERATE=ON` enables the macOS Accelerate/vForce backend; in `auto` mode on macOS, SLEEF is preferred when available and Accelerate remains available as a fallback backend.
 - When `ME_SIMD_MATH_BACKEND=accelerate` is active, the `ME_SIMD_ULP_1` / `ME_SIMD_ULP_3_5` distinction does not select different kernels. Those accuracy modes remain meaningful for the SLEEF backend.
 
 ### Alternative Build Invocations
@@ -121,7 +121,7 @@ The public/runtime-stable DSL JIT controls remain documented in [README.md](READ
 
 ### Internal/Test-Only Environment Variables
 
-- `ME_SIMD_MATH_BACKEND=auto|sleef|accelerate|scalar`: Force the SIMD math backend selection used by `src/functions-simd.c` for benchmarking and debugging. Default: `auto` (`accelerate` on macOS when enabled, otherwise the existing platform backend selection).
+- `ME_SIMD_MATH_BACKEND=auto|sleef|accelerate|scalar`: Force the SIMD math backend selection used by `src/functions-simd.c` for benchmarking and debugging. Default: `auto` (prefers SLEEF when available, otherwise falls back to Accelerate on macOS when enabled, then the existing scalar fallback).
 - The SIMD math benchmarks print backend-aware columns. For `accelerate` and `scalar`, do not interpret the `ME_SIMD_ULP_1` / `ME_SIMD_ULP_3_5` labels as distinct math implementations.
 - `ME_DSL_WHILE_MAX_ITERS=<n>`: Override the runtime safety cap for DSL `while` loops.
 - `ME_DSL_JIT_MATH_BRIDGE=0|1`: Enable or disable runtime math-bridge lowering globally. Default: `1`.

RELEASE_NOTES.md

@@ -4,9 +4,9 @@ Release notes for miniexpr
 Changes from 0.2.0 to 0.2.1
 ===========================
 
-* macOS SIMD math now prefers Accelerate/vForce by default when enabled at build time.
+* macOS SIMD math now prefers SLEEF by default when it is available at build time.
   - New CMake option: `MINIEXPR_USE_ACCELERATE=ON|OFF` (enabled by default on macOS, off elsewhere).
-  - In runtime `auto` mode, macOS uses Accelerate first and falls back to scalar kernels for functions without Accelerate coverage.
+  - In runtime `auto` mode, macOS prefers SLEEF first, then falls back to Accelerate when enabled, then to scalar kernels.
   - Added `ME_SIMD_MATH_BACKEND=auto|sleef|accelerate|scalar` for backend forcing during debugging and benchmarking.
   - Updated SIMD math benchmarks to report backend-appropriate columns instead of implying fake `U10/U35` distinctions for Accelerate/scalar runs.
 

bench/benchmark_transcendentals.c

@@ -141,6 +141,7 @@ static void benchmark_dtype(const dtype_info_t *info, const int *blocks, int nbl
     printf("\n========================================\n");
     printf("Transcendentals chain (%s)\n", info->name);
     printf("========================================\n");
+    printf("Units: BlockKiB = input bytes in KiB, throughput columns = GB/s (10^9 bytes/s)\n");
     if (report_mode == BENCH_REPORT_U35) {
         printf("BlockKiB ME_U10    ME_U35  ME_SCAL       C\n");
     } else if (report_mode == BENCH_REPORT_ACCELERATE) {
@@ -194,14 +195,15 @@ int main(void) {
         {"float32", ME_FLOAT32, sizeof(float)},
         {"float64", ME_FLOAT64, sizeof(double)}
     };
-    const int blocks[] = {1024, 4096, 16384, 65536, 262144, 1048576};
+    const int blocks[] = {4096, 16384, 65536, 262144, 1048576, 4194304};
     const int nblocks = (int)(sizeof(blocks) / sizeof(blocks[0]));
 
     printf("========================================\n");
     printf("MiniExpr Transcendentals Benchmark (Block Sizes)\n");
     printf("========================================\n");
     printf("Backend: %s\n", backend ? backend : "auto");
     printf("Expression: log(exp(x) + tanh(x) + log1p(abs(x)) + sqrt(abs(x)) + expm1(x))\n");
+    printf("Units: block size in KiB, throughput in GB/s (10^9 bytes/s)\n");
 
     for (size_t i = 0; i < sizeof(infos) / sizeof(infos[0]); i++) {
         benchmark_dtype(&infos[i], blocks, nblocks, report_mode);

src/functions-simd.c

@@ -4176,15 +4176,6 @@ static void me_init_simd(void) {
 #endif
     }
 
-#if ME_USE_ACCELERATE && defined(__APPLE__)
-    if (me_simd_backend_preference == ME_SIMD_BACKEND_AUTO) {
-        me_set_accelerate_backend();
-        me_simd_backend = "accelerate";
-        me_dsl_trace_simd_init(use_u35);
-        return;
-    }
-#endif
-
     /* Use SLEEF SIMD kernels when the CPU supports them. */
 #if ME_ENABLE_SLEEF_SIMD && (defined(__x86_64__) || defined(_M_X64) || defined(_M_AMD64))
     if (me_simd_backend_preference != ME_SIMD_BACKEND_ACCELERATE &&
@@ -4433,6 +4424,10 @@ void me_simd_reset_for_tests(void) {
     me_simd_backend = "scalar";
 }
 
+const char *me_simd_backend_for_tests(void) {
+    return me_simd_backend;
+}
+
 void vec_sin_dispatch(const double* a, double* out, int n) {
     if (me_simd_force_scalar) {
         vec_sin_scalar(a, out, n);

src/functions-simd.h

@@ -23,6 +23,7 @@ void me_simd_params_pop(const me_simd_params_state *state);
 void me_sincos_eval_start(void);
 int me_simd_initialized_for_tests(void);
 void me_simd_reset_for_tests(void);
+const char *me_simd_backend_for_tests(void);
 
 void vec_sin_dispatch(const double* a, double* out, int n);
 void vec_cos_dispatch(const double* a, double* out, int n);

tests/test_simd_math.c

@@ -1738,11 +1738,56 @@ static int test_simd_init(void) {
     return 0;
 }
 
+static int test_simd_auto_backend_selection(void) {
+    double data[] = {0.1, 0.2, 0.3, 0.4};
+    double out[4] = {0};
+    const void *vars[] = {data};
+    me_variable v[] = {{"x", ME_FLOAT64, data}};
+    me_expr *expr = NULL;
+    int err = 0;
+    const char *backend;
+
+    if (setenv("ME_SIMD_MATH_BACKEND", "auto", 1) != 0) {
+        printf("Failed to set ME_SIMD_MATH_BACKEND=auto\n");
+        return 1;
+    }
+
+    me_simd_reset_for_tests();
+    if (me_compile("sin(x) + cos(x)", v, 1, ME_FLOAT64, &err, &expr) != ME_COMPILE_SUCCESS) {
+        printf("Failed to compile simd auto backend test (err=%d)\n", err);
+        unsetenv("ME_SIMD_MATH_BACKEND");
+        return 1;
+    }
+
+    if (me_eval(expr, vars, 1, out, 4, NULL) != ME_EVAL_SUCCESS) {
+        printf("me_eval failed in simd auto backend test\n");
+        me_free(expr);
+        unsetenv("ME_SIMD_MATH_BACKEND");
+        return 1;
+    }
+
+    backend = me_simd_backend_for_tests();
+#if defined(__APPLE__) && ME_USE_SLEEF && ME_ENABLE_SLEEF_SIMD && \
+    (defined(__aarch64__) || defined(_M_ARM64))
+    if (strcmp(backend, "advsimd-u10") != 0 && strcmp(backend, "advsimd-u35") != 0) {
+        printf("Expected auto backend to prefer SLEEF on macOS arm64, got %s\n", backend);
+        me_free(expr);
+        unsetenv("ME_SIMD_MATH_BACKEND");
+        return 1;
+    }
+#endif
+
+    me_free(expr);
+    unsetenv("ME_SIMD_MATH_BACKEND");
+    return 0;
+}
+
 int main(void) {
     int failures = 0;
     const int n = 1024;
 
     failures += test_simd_init();
+    failures += test_simd_auto_backend_selection();
     failures += run_unary_pair_f64("abs", fabs, n, -10.0, 10.0, 1e-12);
     failures += run_unary_pair_f64("exp", exp, n, -5.0, 5.0, 1e-12);
     failures += run_unary_pair_f64("expm1", expm1, n, -3.0, 3.0, 1e-12);