numbl 0.3.0 → 0.3.3

package/native/jit_runtime/jit_runtime.c

@@ -1,261 +0,0 @@
-/**
- * numbl_jit_runtime — see jit_runtime.h for the shape and invariants.
- */
-
-#include "jit_runtime.h"
-#include "numbl_ops.h"
-
-#include <math.h>
-#include <string.h>
-#include <time.h>
-
-int numbl_jit_rt_version(void) {
-  return NUMBL_JIT_RT_VERSION;
-}
-
-double numbl_idx1r(const double* data, size_t len, double i, double* err_flag) {
-  /* Truncation-to-zero via int64 cast mirrors JS-JIT's `(i - 1) | 0`.
-   * Unsigned compare catches both negative idx and idx >= len in one
-   * branch. */
-  int64_t idx = (int64_t)(i - 1.0);
-  if ((uint64_t)idx >= (uint64_t)len) {
-    *err_flag = 1.0;
-    return 0.0;
-  }
-  return data[idx];
-}
-
-void numbl_set1r_h(double* data, size_t len, double i, double v,
-                   double* err_flag) {
-  int64_t idx = (int64_t)(i - 1.0);
-  if ((uint64_t)idx >= (uint64_t)len) {
-    /* 2.0 = "growth needed → soft-bail to interpreter", distinct from
-     * 1.0 which the JS wrapper translates into a hard bounds error. */
-    *err_flag = 2.0;
-    return;
-  }
-  data[idx] = v;
-}
-
-double numbl_idx2r(const double* data, size_t len, size_t d0,
-                   double i, double j, double* err_flag) {
-  int64_t r = (int64_t)(i - 1.0);
-  int64_t c = (int64_t)(j - 1.0);
-  /* d0 == 0 would mean an empty tensor — any index is OOB. */
-  if (d0 == 0 || (uint64_t)r >= (uint64_t)d0) {
-    *err_flag = 1.0;
-    return 0.0;
-  }
-  size_t cols = len / d0;
-  if ((uint64_t)c >= (uint64_t)cols) {
-    *err_flag = 1.0;
-    return 0.0;
-  }
-  return data[(size_t)c * d0 + (size_t)r];
-}
-
-double numbl_idx3r(const double* data, size_t len, size_t d0, size_t d1,
-                   double i, double j, double k, double* err_flag) {
-  int64_t k0 = (int64_t)(i - 1.0);
-  int64_t k1 = (int64_t)(j - 1.0);
-  int64_t k2 = (int64_t)(k - 1.0);
-  if (d0 == 0 || d1 == 0 ||
-      (uint64_t)k0 >= (uint64_t)d0 ||
-      (uint64_t)k1 >= (uint64_t)d1) {
-    *err_flag = 1.0;
-    return 0.0;
-  }
-  size_t plane = d0 * d1;
-  size_t d2 = len / plane;
-  if ((uint64_t)k2 >= (uint64_t)d2) {
-    *err_flag = 1.0;
-    return 0.0;
-  }
-  return data[(size_t)k2 * plane + (size_t)k1 * d0 + (size_t)k0];
-}
-
-void numbl_set2r_h(double* data, size_t len, size_t d0,
-                   double i, double j, double v, double* err_flag) {
-  int64_t r = (int64_t)(i - 1.0);
-  int64_t c = (int64_t)(j - 1.0);
-  if (d0 == 0) {
-    *err_flag = 2.0;
-    return;
-  }
-  size_t cols = len / d0;
-  if ((uint64_t)r >= (uint64_t)d0 || (uint64_t)c >= (uint64_t)cols) {
-    *err_flag = 2.0;
-    return;
-  }
-  data[(size_t)c * d0 + (size_t)r] = v;
-}
-
-void numbl_set3r_h(double* data, size_t len, size_t d0, size_t d1,
-                   double i, double j, double k, double v,
-                   double* err_flag) {
-  int64_t k0 = (int64_t)(i - 1.0);
-  int64_t k1 = (int64_t)(j - 1.0);
-  int64_t k2 = (int64_t)(k - 1.0);
-  if (d0 == 0 || d1 == 0) {
-    *err_flag = 2.0;
-    return;
-  }
-  size_t plane = d0 * d1;
-  size_t d2 = len / plane;
-  if ((uint64_t)k0 >= (uint64_t)d0 ||
-      (uint64_t)k1 >= (uint64_t)d1 ||
-      (uint64_t)k2 >= (uint64_t)d2) {
-    *err_flag = 2.0;
-    return;
-  }
-  data[(size_t)k2 * plane + (size_t)k1 * d0 + (size_t)k0] = v;
-}
-
-void numbl_setRange1r_h(double* dstData, size_t dstLen,
-                        double dstStart, double dstEnd,
-                        const double* srcData, size_t srcLen,
-                        double srcStart, double srcEnd,
-                        double* err_flag) {
-  int64_t dS = (int64_t)(dstStart - 1.0);
-  int64_t dE = (int64_t)(dstEnd - 1.0);
-  int64_t sS = (int64_t)(srcStart - 1.0);
-  int64_t sE = (int64_t)(srcEnd - 1.0);
-  int64_t dN = dE - dS + 1;
-  int64_t sN = sE - sS + 1;
-  if (dN != sN) {
-    /* 3.0 — length-mismatch error; JS wrapper translates to MATLAB's
-     * "Unable to perform assignment..." message. */
-    *err_flag = 3.0;
-    return;
-  }
-  if (dN <= 0) return;
-  if ((uint64_t)dS >= (uint64_t)dstLen ||
-      (uint64_t)dE >= (uint64_t)dstLen ||
-      (uint64_t)sS >= (uint64_t)srcLen ||
-      (uint64_t)sE >= (uint64_t)srcLen) {
-    *err_flag = 1.0;
-    return;
-  }
-  /* memmove handles overlap when src and dst alias. */
-  memmove(dstData + (size_t)dS, srcData + (size_t)sS,
-          (size_t)dN * sizeof(double));
-}
-
-void numbl_setCol2r_h(double* dstData, size_t dstRows, size_t dstLen,
-                      double col,
-                      const double* srcData, size_t srcLen,
-                      double* err_flag) {
-  if (srcLen != dstRows) {
-    *err_flag = 3.0;
-    return;
-  }
-  int64_t j = (int64_t)(col - 1.0);
-  if (j < 0) {
-    *err_flag = 1.0;
-    return;
-  }
-  if (dstRows == 0) {
-    /* Empty dst with a nonempty src: growth territory — soft-bail. */
-    *err_flag = 2.0;
-    return;
-  }
-  size_t dstCols = dstLen / dstRows;
-  if ((uint64_t)j >= (uint64_t)dstCols) {
-    /* Growth on write — the interpreter handles growing dst; JS-JIT
-     * mirrors this with JitBailToInterpreter. */
-    *err_flag = 2.0;
-    return;
-  }
-  memcpy(dstData + (size_t)j * dstRows, srcData,
-         dstRows * sizeof(double));
-}
-
-void numbl_copyRange1r(const double* srcData, size_t srcLen,
-                       double start, double end,
-                       double* dstData,
-                       double* err_flag) {
-  int64_t s = (int64_t)(start - 1.0);
-  int64_t e = (int64_t)(end - 1.0);
-  int64_t n = e - s + 1;
-  if (n <= 0) return;
-  if ((uint64_t)s >= (uint64_t)srcLen ||
-      (uint64_t)e >= (uint64_t)srcLen) {
-    *err_flag = 1.0;
-    return;
-  }
-  memcpy(dstData, srcData + (size_t)s, (size_t)n * sizeof(double));
-}
-
-double numbl_mod(double a, double b) {
-  if (b == 0.0) return a;
-  double r = fmod(a, b);
-  if (r != 0.0 && ((r < 0.0) != (b < 0.0))) r += b;
-  return r;
-}
-
-double numbl_sign(double x) {
-  if (x > 0.0) return 1.0;
-  if (x < 0.0) return -1.0;
-  return 0.0;
-}
-
-double numbl_reduce_flat(int op, const double* data, int64_t len) {
-  double out = 0.0;
-  numbl_real_flat_reduce(op, (size_t)len, data, &out);
-  return out;
-}
-
-double numbl_monotonic_time(void) {
-  struct timespec ts;
-  clock_gettime(CLOCK_MONOTONIC, &ts);
-  return (double)ts.tv_sec + (double)ts.tv_nsec * 1e-9;
-}
-
-double numbl_tic(double* state) {
-  double t = numbl_monotonic_time();
-  *state = t;
-  return t;
-}
-
-double numbl_toc(const double* state) {
-  return numbl_monotonic_time() - *state;
-}
-
-/* ── NaN / Inf / finite predicates ─────────────────────────────────────
- *
- * Bit-pattern inspection so the answer doesn't depend on the caller's
- * `-ffast-math` / `-ffinite-math-only` posture. IEEE-754 binary64
- * double: sign bit (1) | exponent (11) | mantissa (52). NaN has
- * exponent all-1s and non-zero mantissa; ±Inf has exponent all-1s and
- * zero mantissa; finite values have exponent != all-1s.
- *
- * memcpy is the portable way to reinterpret the bit pattern (type-
- * punning through a union is UB in strict C; the compiler may still
- * generate a type-punning read from memcpy as a single mov on any
- * real platform).
- */
-
-static uint64_t bits_of(double x) {
-  uint64_t u;
-  memcpy(&u, &x, sizeof u);
-  return u;
-}
-
-#define NUMBL_DBL_EXP_MASK 0x7FF0000000000000ULL
-#define NUMBL_DBL_MANT_MASK 0x000FFFFFFFFFFFFFULL
-
-int numbl_is_nan(double x) {
-  uint64_t u = bits_of(x);
-  return (u & NUMBL_DBL_EXP_MASK) == NUMBL_DBL_EXP_MASK
-      && (u & NUMBL_DBL_MANT_MASK) != 0;
-}
-
-int numbl_is_inf(double x) {
-  uint64_t u = bits_of(x);
-  return (u & ~0x8000000000000000ULL) == NUMBL_DBL_EXP_MASK;
-}
-
-int numbl_is_finite(double x) {
-  uint64_t u = bits_of(x);
-  return (u & NUMBL_DBL_EXP_MASK) != NUMBL_DBL_EXP_MASK;
-}

package/native/jit_runtime/jit_runtime.h

@@ -1,204 +0,0 @@
-/**
- * numbl_jit_runtime — helpers the C-JIT emitter calls from generated code.
- *
- * Kept in a static archive (jit_runtime.a) separate from numbl_ops.a:
- * the `ops/` directory is reserved for op-code-dispatched kernels that
- * achieve parity with the TS ops layer. Anything the JIT emitter calls
- * *directly* from emitted C (bounds-checked index reads, MATLAB-semantics
- * math helpers, tic/toc, reduction shims, ...) lives here instead.
- *
- * When adding a new helper, bump NUMBL_JIT_RT_VERSION below AND
- * NUMBL_JIT_RT_REQUIRED_VERSION in jitCodegenC.ts. The generated C asserts
- * `NUMBL_JIT_RT_VERSION >= N`, so a stale archive fails the per-JIT
- * compile step with a clear "rebuild the addon" message instead of a
- * cryptic linker error.
- */
-
-#ifndef NUMBL_JIT_RUNTIME_H
-#define NUMBL_JIT_RUNTIME_H
-
-#include <stddef.h>
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* ── Version ──────────────────────────────────────────────────────────── */
-
-/**
- * Version log:
- *   1 — initial: idx1r, mod, sign, reduce_flat, tic/toc/monotonic_time.
- *   2 — set1r_h (scalar linear Index write with soft-bail on OOB).
- *   3 — idx2r / idx3r / set2r_h / set3r_h (multi-index Index read/write).
- *   4 — setRange1r_h / setCol2r_h / copyRange1r (range/col slice r/w).
- *   5 — is_nan / is_inf / is_finite (predicates that survive -ffast-math
- *       by inspecting IEEE-754 bit patterns, not FP ops).
- */
-#define NUMBL_JIT_RT_VERSION 5
-
-/** Returns NUMBL_JIT_RT_VERSION baked into the compiled archive. */
-int numbl_jit_rt_version(void);
-
-/* ── Scalar linear Index read ─────────────────────────────────────────── */
-
-/**
- * 1-based MATLAB linear Index read on a real-valued tensor buffer.
- *
- *   `i` — 1-based double index (truncation-to-zero via int64 cast). The
- *         emitter wraps non-integer indices with `round()` beforehand to
- *         match the JS-JIT's `Math.round`-then-truncate sequence.
- *   `err_flag` — set to 1.0 on OOB (and returns 0.0) so the C function
- *                finishes without a native crash. The caller must zero
- *                the flag before each koffi call; the JS wrapper checks
- *                it after and throws "Index exceeds array bounds".
- */
-double numbl_idx1r(const double* data, size_t len, double i, double* err_flag);
-
-/**
- * 1-based MATLAB linear Index write on a real-valued tensor buffer.
- *
- * On OOB, writes `2.0` to *err_flag (the "growth-needed" code the JS
- * wrapper translates to a JitBailToInterpreter) and returns without
- * writing, mirroring the JS-JIT's `set1r_h` helper. The interpreter
- * then re-runs the call with proper tensor-growth semantics. As with
- * the read path, the caller must zero the flag before each call.
- */
-void numbl_set1r_h(double* data, size_t len, double i, double v, double* err_flag);
-
-/* ── Multi-index Index read (2D, 3D) ──────────────────────────────────── */
-
-/**
- * 1-based MATLAB 2D Index read on a real-valued tensor buffer.
- *
- * Column-major: returns data[(j-1)*d0 + (i-1)]. `d0` is the row count.
- * The derived column count is `len / d0`; both dimensions are bounds-
- * checked independently. Emitter wraps non-integer indices with
- * `round()` to match the JS-JIT's `Math.round`-then-truncate sequence.
- * On OOB, sets *err_flag = 1.0 and returns 0.0 (hard bounds error).
- */
-double numbl_idx2r(const double* data, size_t len, size_t d0,
-                   double i, double j, double* err_flag);
-
-/**
- * 1-based MATLAB 3D Index read on a real-valued tensor buffer.
- *
- * Column-major: returns data[((k-1)*d1 + (j-1))*d0 + (i-1)]. `d0` is
- * the row count, `d1` the column count. The derived page count is
- * `len / (d0 * d1)`; each dimension is bounds-checked independently.
- */
-double numbl_idx3r(const double* data, size_t len, size_t d0, size_t d1,
-                   double i, double j, double k, double* err_flag);
-
-/* ── Multi-index Index write (2D, 3D), soft-bail on OOB ───────────────── */
-
-/**
- * 2D Index write. On OOB (along either dim) writes `2.0` to *err_flag
- * (the "growth-needed" code the JS wrapper translates to a
- * JitBailToInterpreter) and returns without writing.
- */
-void numbl_set2r_h(double* data, size_t len, size_t d0,
-                   double i, double j, double v, double* err_flag);
-
-/** 3D Index write with the same soft-bail convention as set2r_h. */
-void numbl_set3r_h(double* data, size_t len, size_t d0, size_t d1,
-                   double i, double j, double k, double v,
-                   double* err_flag);
-
-/* ── Range / column slice read and write ──────────────────────────────── */
-
-/**
- * Range → range write: `dst(dStart:dEnd) = src(sStart:sEnd)` on real
- * tensors, 1-based MATLAB indices. Sizes must match: on mismatch,
- * writes `3.0` to *err_flag and returns (the JS wrapper translates this
- * into "Unable to perform assignment because the indices on the left
- * side are not compatible with the size of the right side."). Bounds
- * violations on either range write `1.0` and return. Uses memmove so
- * overlapping dst == src ranges are handled correctly.
- */
-void numbl_setRange1r_h(double* dstData, size_t dstLen,
-                        double dstStart, double dstEnd,
-                        const double* srcData, size_t srcLen,
-                        double srcStart, double srcEnd,
-                        double* err_flag);
-
-/**
- * Column-vector write into column `col` of a 2-D tensor `dst` with row
- * count `dstRows`. `srcLen` must equal `dstRows` (length mismatch →
- * *err_flag = 3.0). When `col` exceeds the current column count, the
- * MATLAB interpreter would grow dst — we soft-bail (*err_flag = 2.0) so
- * the caller's stale hoisted aliases don't corrupt the growth path.
- */
-void numbl_setCol2r_h(double* dstData, size_t dstRows, size_t dstLen,
-                      double col,
-                      const double* srcData, size_t srcLen,
-                      double* err_flag);
-
-/**
- * Range read: copy `src(start:end)` into caller-provided `dstData`. The
- * caller must ensure `dstData` has capacity >= `end - start + 1`. OOB
- * on `src` writes `1.0` to *err_flag and returns without writing.
- * `start > end` is a valid empty range (no write, no error).
- */
-void numbl_copyRange1r(const double* srcData, size_t srcLen,
-                       double start, double end,
-                       double* dstData,
-                       double* err_flag);
-
-/* ── Scalar math helpers with MATLAB semantics ────────────────────────── */
-
-/** MATLAB `mod(a, b)`: result has the sign of `b`; `mod(a, 0) == a`. */
-double numbl_mod(double a, double b);
-
-/** Three-valued sign: -1, 0, or 1. */
-double numbl_sign(double x);
-
-/* ── Reduction wrapper ────────────────────────────────────────────────── */
-
-/**
- * Thin wrapper around numbl_real_flat_reduce (from numbl_ops.a) that
- * returns the scalar directly, so generated C doesn't need a local
- * `double out; … ; return out;` dance inline.
- */
-double numbl_reduce_flat(int op, const double* data, int64_t len);
-
-/* ── Timers (tic/toc) ─────────────────────────────────────────────────── */
-
-/**
- * Monotonic wall-clock seconds. Exported by every JIT .so so the JS
- * wrapper can cross-reference the C clock domain when bridging tic/toc
- * state between JS and C.
- */
-double numbl_monotonic_time(void);
-
-/** Capture the current monotonic time into *state, return it. */
-double numbl_tic(double* state);
-
-/** Elapsed seconds since *state. */
-double numbl_toc(const double* state);
-
-/* ── NaN / Inf / finite predicates ───────────────────────────────────── */
-
-/**
- * Bit-pattern-based predicates that return 1 for true, 0 for false.
- *
- * The JIT emits calls to these instead of C99's `isnan` / `isinf` /
- * `isfinite` because the generated C is compiled with `-ffast-math`,
- * which implies `-ffinite-math-only` and constant-folds those macros
- * away. These helpers inspect the IEEE-754 bit pattern via `memcpy`,
- * so the optimizer can't prove they're always-false even if the
- * caller's `-ffast-math` assumes operands are finite — the function
- * call is opaque, and the bit operations have no FP semantics.
- *
- * Assumes IEEE-754 binary64 doubles (true on every platform numbl
- * targets).
- */
-int numbl_is_nan(double x);
-int numbl_is_inf(double x);
-int numbl_is_finite(double x);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* NUMBL_JIT_RUNTIME_H */