@scriptc/cli-darwin-x64 0.2.4 → 0.2.6

package/dist/lib/runtime-sources/src/scr_shared.c

@@ -0,0 +1,280 @@
+/* Shared storage is neutral: only its backing allocation and synchronization
+ * cross contexts. ScrBytes wrappers and their reference counts remain local. */
+#include "scr_runtime.h"
+#include "scr_numeric.h"
+#include <math.h>
+#include <stdatomic.h>
+#include <stdlib.h>
+#include <time.h>
+#if defined(SCR_WORKERS) || (defined(SCR_LIB) && defined(SCR_THREAD_INSTANCES))
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <pthread.h>
+#include <time.h>
+#endif
+#endif
+
+struct ScrSharedBytes {
+  atomic_size_t references;
+  size_t length;
+  uint8_t *data;
+};
+
+#if defined(SCR_WORKERS) || (defined(SCR_LIB) && defined(SCR_THREAD_INSTANCES))
+#ifdef _WIN32
+static SRWLOCK scr_shared_mutex = SRWLOCK_INIT;
+static CONDITION_VARIABLE scr_shared_condition = CONDITION_VARIABLE_INIT;
+#else
+static pthread_mutex_t scr_shared_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t scr_shared_condition = PTHREAD_COND_INITIALIZER;
+#endif
+static SCR_TL unsigned scr_shared_depth;
+#endif
+
+/* One ordering domain covers overlapping views of different widths. Recursive
+ * runtime helpers may nest, but no caller may execute script while holding it. */
+void scr_shared_enter(void) {
+#if defined(SCR_WORKERS) || (defined(SCR_LIB) && defined(SCR_THREAD_INSTANCES))
+  if (scr_shared_depth++ != 0) return;
+#ifdef _WIN32
+  AcquireSRWLockExclusive(&scr_shared_mutex);
+#else
+  pthread_mutex_lock(&scr_shared_mutex);
+#endif
+#endif
+}
+
+void scr_shared_leave(void) {
+#if defined(SCR_WORKERS) || (defined(SCR_LIB) && defined(SCR_THREAD_INSTANCES))
+  if (--scr_shared_depth != 0) return;
+#ifdef _WIN32
+  ReleaseSRWLockExclusive(&scr_shared_mutex);
+#else
+  pthread_mutex_unlock(&scr_shared_mutex);
+#endif
+#endif
+}
+
+bool scr_shared_guard(const ScrBytes *a, const ScrBytes *b) {
+  bool shared = (a && a->shared) || (b && b->shared);
+  if (shared) scr_shared_enter();
+  return shared;
+}
+
+void scr_shared_guard_release(bool *held) { if (*held) scr_shared_leave(); }
+
+ScrSharedBytes *scr_shared_retain(ScrSharedBytes *storage) {
+  atomic_fetch_add_explicit(&storage->references, 1, memory_order_relaxed);
+  return storage;
+}
+
+void scr_shared_release(ScrSharedBytes *storage) {
+  if (!storage || atomic_fetch_sub_explicit(&storage->references, 1, memory_order_acq_rel) != 1) return;
+  free(storage->data);
+  free(storage);
+}
+
+void scr_bytes_make_shared(ScrBytes *bytes) {
+  if (bytes->backing || bytes->shared || bytes->external) scr_trap("scriptc: invalid shared storage owner\n");
+  ScrSharedBytes *storage = malloc(sizeof(*storage));
+  if (!storage) scr_trap("scriptc: out of memory\n");
+  atomic_init(&storage->references, 1);
+  storage->length = bytes->len * scr_bytes_elem_size(bytes->elem);
+  storage->data = bytes->data;
+  bytes->shared = storage;
+}
+
+ScrBytes *scr_shared_wrap(ScrSharedBytes *storage) {
+  ScrBytes *bytes = scr_bytes_from_external(storage->data, storage->length);
+  bytes->external = false;
+  bytes->shared = scr_shared_retain(storage);
+  return bytes;
+}
+
+void scr_bytes_read(const ScrBytes *bytes, size_t offset, void *out, size_t length) {
+  SCR_SHARED_GUARD(bytes, NULL);
+  if (length) memcpy(out, bytes->data + offset, length);
+}
+
+void scr_bytes_write(ScrBytes *bytes, size_t offset, const void *data, size_t length) {
+  SCR_SHARED_GUARD(bytes, NULL);
+  if (length) memcpy(bytes->data + offset, data, length);
+}
+
+ScrStr *scr_bytes_string(const ScrBytes *bytes, size_t offset, size_t length) {
+  SCR_SHARED_GUARD(bytes, NULL);
+  return scr_str_new((const char *)bytes->data + offset, length);
+}
+
+ScrBytes *scr_bytes_snapshot(const ScrBytes *bytes) {
+  if (!bytes || !bytes->shared) return NULL;
+  ScrBytes *copy = scr_bytes_copy(bytes);
+  copy->is_buffer = bytes->is_buffer;
+  copy->is_data_view = bytes->is_data_view;
+  return copy;
+}
+
+void scr_bytes_snapshot_release(ScrBytes **bytes) { scr_bytes_release(*bytes); }
+
+ScrBytes *scr_bytes_local_copy(ScrBytes *bytes) {
+  ScrBytes *copy = scr_bytes_snapshot(bytes);
+  return copy ? copy : scr_bytes_retain(bytes);
+}
+
+void scr_bytes_require_unshared(const ScrBytes *bytes) {
+  if (!bytes->shared) return;
+  static const char message[] = "Shared byte storage cannot expose an unmanaged native pointer";
+  scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020");
+}
+
+static bool scr_atomics_index(ScrBytes *bytes, double index, bool waitable, size_t *out) {
+  bool integer = bytes->elem == SCR_BYTES_I8 || bytes->elem == SCR_BYTES_U8 ||
+    bytes->elem == SCR_BYTES_I16 || bytes->elem == SCR_BYTES_U16 ||
+    bytes->elem == SCR_BYTES_I32 || bytes->elem == SCR_BYTES_U32;
+  if (bytes->is_data_view || !integer || (waitable && bytes->elem != SCR_BYTES_I32)) {
+    static const char message[] = "The typed array is not an integer typed array of the required kind";
+    scr_throw_error_msg(SCR_ERR_TYPE, message, sizeof message - 1);
+    return false;
+  }
+  double normalized = isnan(index) ? 0 : trunc(index);
+  if (!(normalized >= 0) || normalized >= (double)bytes->len) {
+    static const char message[] = "Invalid atomic access index";
+    scr_throw_error_msg(SCR_ERR_RANGE, message, sizeof message - 1);
+    return false;
+  }
+  *out = (size_t)normalized;
+  return true;
+}
+
+/* Operations: load, store, exchange, compareExchange, add, sub, and, or, xor.
+ * Unsigned arithmetic avoids signed overflow; the element store supplies the
+ * selected width and signedness. The lock gives one sequentially consistent
+ * order shared with ordinary accesses, including overlapping DataViews. */
+double scr_atomics_op(ScrBytes *bytes, double index, double value, double replacement, double operation) {
+  size_t i;
+  if (!scr_atomics_index(bytes, index, false, &i)) return 0;
+  SCR_SHARED_GUARD(bytes, NULL);
+  double previous = scr_bytes_get(bytes, (double)i);
+  uint32_t before = scr_numeric_to_u32(previous), operand = scr_numeric_to_u32(value);
+  uint32_t after;
+  switch ((int)operation) {
+  case 0: return previous;
+  case 1:
+    scr_bytes_set(bytes, (double)i, value);
+    return isnan(value) || value == 0 ? 0 : trunc(value);
+  case 2: after = operand; break;
+  case 3: {
+    unsigned bits = (unsigned)scr_bytes_elem_size(bytes->elem) * 8;
+    uint32_t mask = bits == 32 ? UINT32_MAX : (UINT32_C(1) << bits) - 1;
+    if ((before & mask) != (operand & mask)) return previous;
+    after = scr_numeric_to_u32(replacement);
+    break;
+  }
+  case 4: after = before + operand; break;
+  case 5: after = before - operand; break;
+  case 6: after = before & operand; break;
+  case 7: after = before | operand; break;
+  case 8: after = before ^ operand; break;
+  default: scr_trap("scriptc: invalid atomic operation\n");
+  }
+  scr_bytes_set(bytes, (double)i, (double)after);
+  return previous;
+}
+
+typedef struct ScrAtomicWaiter {
+  ScrSharedBytes *storage;
+  size_t offset;
+  bool notified;
+  struct ScrAtomicWaiter *next;
+} ScrAtomicWaiter;
+static ScrAtomicWaiter *scr_atomic_waiters;
+
+static void scr_atomics_pause(double ms) {
+#if defined(SCR_WORKERS) || (defined(SCR_LIB) && defined(SCR_THREAD_INSTANCES))
+#ifdef _WIN32
+  SleepConditionVariableSRW(&scr_shared_condition, &scr_shared_mutex, (DWORD)ceil(ms), 0);
+#else
+  struct timespec until;
+  clock_gettime(CLOCK_REALTIME, &until);
+  until.tv_nsec += (long)(ms * 1000000.0);
+  until.tv_sec += until.tv_nsec / 1000000000;
+  until.tv_nsec %= 1000000000;
+  pthread_cond_timedwait(&scr_shared_condition, &scr_shared_mutex, &until);
+#endif
+#else
+  struct timespec duration = {(time_t)(ms / 1000), (long)(fmod(ms, 1000) * 1000000)};
+  nanosleep(&duration, NULL);
+#endif
+}
+
+ScrStr *scr_atomics_wait(ScrBytes *bytes, double index, double expected, double timeout) {
+  size_t i;
+  if (!scr_atomics_index(bytes, index, true, &i)) return NULL;
+  if (!bytes->shared) {
+    static const char message[] = "[object Int32Array] is not a shared typed array.";
+    scr_throw_error_msg(SCR_ERR_TYPE, message, sizeof message - 1);
+    return NULL;
+  }
+  int32_t compare;
+  uint32_t bits = scr_numeric_to_u32(expected);
+  memcpy(&compare, &bits, sizeof compare);
+  scr_shared_enter();
+  if (scr_bytes_get(bytes, (double)i) != compare) {
+    scr_shared_leave();
+    return scr_str_new("not-equal", 9);
+  }
+  double duration = isnan(timeout) ? INFINITY : fmax(timeout, 0);
+  double end = scr_perf_now() + duration;
+  ScrAtomicWaiter waiter = {bytes->shared, (size_t)(bytes->data - bytes->shared->data) + i * 4, false, NULL};
+  ScrAtomicWaiter **tail = &scr_atomic_waiters;
+  while (*tail) tail = &(*tail)->next;
+  *tail = &waiter;
+  bool stopped = false;
+  while (!waiter.notified) {
+    double remaining = end - scr_perf_now();
+    if (!(remaining > 0)) break;
+    /* A bounded wait gives cooperative termination a safe cancellation point.
+     * Registration and condition release share the notify lock: no wakeup can
+     * fall between the expected-value check and entering the wait. */
+    scr_atomics_pause(fmin(remaining, 10));
+#if defined(SCR_WORKERS) || (defined(SCR_LIB) && defined(SCR_THREAD_INSTANCES))
+    scr_shared_leave();
+#ifdef SCR_WORKERS
+    stopped = scr_context_checkpoint();
+#endif
+    scr_shared_enter();
+    if (stopped) break;
+#endif
+  }
+  ScrAtomicWaiter **slot = &scr_atomic_waiters;
+  while (*slot != &waiter) slot = &(*slot)->next;
+  *slot = waiter.next;
+  scr_shared_leave();
+  return stopped ? NULL : scr_str_new(waiter.notified ? "ok" : "timed-out", waiter.notified ? 2 : 9);
+}
+
+double scr_atomics_notify(ScrBytes *bytes, double index, double count) {
+  size_t i;
+  if (!scr_atomics_index(bytes, index, true, &i)) return 0;
+  if (!bytes->shared) return 0;
+  double limit = isnan(count) ? 0 : fmax(trunc(count), 0);
+  size_t offset = (size_t)(bytes->data - bytes->shared->data) + i * 4;
+  double notified = 0;
+  scr_shared_enter();
+  for (ScrAtomicWaiter *waiter = scr_atomic_waiters; waiter && notified < limit; waiter = waiter->next) {
+    if (waiter->storage == bytes->shared && waiter->offset == offset && !waiter->notified) {
+      waiter->notified = true;
+      notified++;
+    }
+  }
+#if defined(SCR_WORKERS) || (defined(SCR_LIB) && defined(SCR_THREAD_INSTANCES))
+#ifdef _WIN32
+  if (notified) WakeAllConditionVariable(&scr_shared_condition);
+#else
+  if (notified) pthread_cond_broadcast(&scr_shared_condition);
+#endif
+#endif
+  scr_shared_leave();
+  return notified;
+}

package/dist/lib/runtime-sources/src/scr_shared.test.c

@@ -0,0 +1,113 @@
+#undef NDEBUG
+#include "scr_runtime.h"
+#include <assert.h>
+#include <math.h>
+#include <pthread.h>
+#include <sched.h>
+#include <stdatomic.h>
+#include <stdio.h>
+
+enum { THREADS = 4, INCREMENTS = 10000 };
+static atomic_uint ready;
+static atomic_bool cancel_wait;
+typedef struct { ScrSharedBytes *storage; unsigned id; bool waiting; } Task;
+
+static void *run(void *ptr) {
+  Task *task = ptr;
+  scr_context_enter(task->id);
+  scr_init();
+  scr_lib_init(0, NULL);
+  ScrBytes *storage = scr_shared_wrap(task->storage);
+  scr_shared_release(task->storage);
+  ScrBytes *values = scr_bytes_buffer_view(storage, SCR_BYTES_I32, 4, true, 2);
+  ScrBytes *view = scr_dataview_new(storage, 12, true, 4);
+  atomic_fetch_add_explicit(&ready, 1, memory_order_release);
+  if (task->waiting) {
+    scr_context_stop_flag(&cancel_wait);
+    ScrStr *result = scr_atomics_wait(values, 0, 0, INFINITY);
+    if (task->id == 1) {
+      assert(result && result->len == 2 && !memcmp(result->data, "ok", 2));
+      scr_str_release(result);
+    } else assert(!result && scr_context_stopping());
+  } else {
+    while (atomic_load_explicit(&ready, memory_order_acquire) != THREADS) sched_yield();
+    for (unsigned i = 0; i < INCREMENTS; i++) {
+      scr_atomics_op(values, 0, 1, 0, 4);
+      /* These accesses overlap the same shared address with different view
+       * metadata. Non-atomic JS accesses must still be C data-race-free. */
+      scr_dataview_set(view, 0, 0x12345678, SCR_DV_U32, true);
+      assert(scr_dataview_get(view, 0, SCR_DV_U32, true) == 0x12345678);
+      scr_bytes_set(values, 1, -7);
+      assert(scr_bytes_get(values, 1) == -7);
+      if (i % 100 == 0) {
+        ScrBytes *copy = scr_bytes_local_copy(storage);
+        assert(!copy->shared && copy->data != storage->data && copy->len == storage->len);
+        scr_bytes_release(copy);
+        ScrStr *text = scr_bytes_string(storage, 0, storage->len);
+        assert(text->len == storage->len);
+        scr_str_release(text);
+      }
+    }
+  }
+  scr_bytes_release(values);
+  scr_bytes_release(view);
+  scr_bytes_release(storage);
+  scr_context_cleanup();
+  return NULL;
+}
+
+int main(void) {
+  scr_init();
+  scr_lib_init(0, NULL);
+  ScrBytes *storage = scr_bytes_new(SCR_BYTES_U8, 16);
+  scr_bytes_make_shared(storage);
+  ScrBytes *values = scr_bytes_buffer_view(storage, SCR_BYTES_I32, 4, true, 2);
+  scr_bytes_require_unshared(values);
+  assert(scr_exc_pending());
+  scr_exc_clear();
+  ScrBytes *local = scr_bytes_new(SCR_BYTES_U8, 2);
+  ScrBytes *retained = scr_bytes_local_copy(local);
+  assert(retained == local);
+  scr_bytes_require_unshared(local);
+  assert(!scr_exc_pending());
+  scr_bytes_release(retained);
+  scr_bytes_release(local);
+  pthread_t threads[THREADS];
+  Task tasks[THREADS];
+  for (unsigned i = 0; i < THREADS; i++) {
+    tasks[i] = (Task){scr_shared_retain(storage->shared), i + 1, false};
+    assert(!pthread_create(&threads[i], NULL, run, &tasks[i]));
+  }
+  for (unsigned i = 0; i < THREADS; i++) assert(!pthread_join(threads[i], NULL));
+  assert(scr_bytes_get(values, 0) == THREADS * INCREMENTS);
+  assert(scr_atomics_op(values, 0, 3.9, 0, 1) == 3);
+  assert(scr_atomics_op(values, 0, 3, 0xffffffff, 3) == 3);
+  assert(scr_atomics_op(values, 0, 0, 0, 0) == -1);
+  assert(scr_atomics_op(values, 0, 0, 0, 2) == -1);
+  ScrStr *status = scr_atomics_wait(values, 0, 1, INFINITY);
+  assert(status && !strcmp(status->data, "not-equal"));
+  scr_str_release(status);
+  status = scr_atomics_wait(values, 0, 0, 0);
+  assert(status && !strcmp(status->data, "timed-out"));
+  scr_str_release(status);
+
+  tasks[0] = (Task){scr_shared_retain(storage->shared), 1, true};
+  assert(!pthread_create(&threads[0], NULL, run, &tasks[0]));
+  double deadline = scr_perf_now() + 5000;
+  while (scr_atomics_notify(values, 0, 1) == 0) {
+    assert(scr_perf_now() < deadline);
+    sched_yield();
+  }
+  assert(!pthread_join(threads[0], NULL));
+  assert(scr_atomics_notify(values, 0, INFINITY) == 0);
+
+  tasks[0] = (Task){scr_shared_retain(storage->shared), 2, true};
+  assert(!pthread_create(&threads[0], NULL, run, &tasks[0]));
+  atomic_store_explicit(&cancel_wait, true, memory_order_relaxed);
+  assert(!pthread_join(threads[0], NULL));
+  assert(scr_atomics_notify(values, 0, INFINITY) == 0);
+  scr_bytes_release(values);
+  scr_bytes_release(storage);
+  scr_context_cleanup();
+  puts("shared views preserve atomic updates, wait queues and cancellation ownership");
+}

package/dist/lib/runtime-sources/src/scr_shared.test.ts

@@ -0,0 +1,45 @@
+import { execFile } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { expect, test } from "vitest";
+import { EXECUTABLE_RUNTIME_SOURCES } from "../../compiler/src/backend/native-toolchain.js";
+
+const exec = promisify(execFile);
+
+test.skipIf(process.platform === "win32")(
+  "shared views serialize concurrent accesses and cancel parked waiters",
+  async () => {
+    const dir = await mkdtemp(join(tmpdir(), "scriptc-shared-"));
+    try {
+      const bin = join(dir, "shared");
+      await exec("clang", [
+        "-std=c11",
+        "-O1",
+        "-pthread",
+        "-DSCR_WORKERS",
+        "-DSCR_RC_AUDIT",
+        "-fsanitize=address,undefined",
+        "-Wno-deprecated-declarations",
+        ...(process.platform === "linux" ? ["-D_GNU_SOURCE"] : []),
+        ...["scr_shared.test.c", ...EXECUTABLE_RUNTIME_SOURCES].map((name) =>
+          join(import.meta.dirname, name),
+        ),
+        ...(process.platform === "linux" ? ["-lm"] : []),
+        "-o",
+        bin,
+      ]);
+      const result = await exec(bin, [], {
+        timeout: 10000,
+        env: { ...process.env, UBSAN_OPTIONS: "halt_on_error=1" },
+      });
+      expect(result.stdout).toBe(
+        "shared views preserve atomic updates, wait queues and cancellation ownership\n",
+      );
+      expect(result.stderr).toBe("");
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  },
+);

package/dist/lib/runtime-sources/src/scr_stream.c

@@ -183,11 +183,11 @@ struct ScrStreamState {
  * user class whose preorder number happens to collide (scr_stream_is
  * below tests interval membership for compiler-emitted subclasses). */
 static void scr_stream_release_direct(void *obj);
-ScrVt scr_readable_vt = {1, 0, &scr_stream_release_direct};
-ScrVt scr_writable_vt = {1, 0, &scr_stream_release_direct};
-ScrVt scr_duplex_vt = {1, 0, &scr_stream_release_direct};
-ScrVt scr_transform_vt = {1, 0, &scr_stream_release_direct};
-ScrVt scr_passthrough_vt = {1, 0, &scr_stream_release_direct};
+SCR_TL ScrVt scr_readable_vt = {1, 0, &scr_stream_release_direct};
+SCR_TL ScrVt scr_writable_vt = {1, 0, &scr_stream_release_direct};
+SCR_TL ScrVt scr_duplex_vt = {1, 0, &scr_stream_release_direct};
+SCR_TL ScrVt scr_transform_vt = {1, 0, &scr_stream_release_direct};
+SCR_TL ScrVt scr_passthrough_vt = {1, 0, &scr_stream_release_direct};
 
 static bool scr_vt_within(const ScrVt *vt, const ScrVt *cls) {
   return cls->pre <= vt->pre && vt->pre <= cls->post;
@@ -353,8 +353,8 @@ typedef struct ScrStreamTick {
   struct ScrStreamTick *next;
 } ScrStreamTick;
 
-static ScrStreamTick *scr_st_head = NULL;
-static ScrStreamTick *scr_st_tail = NULL;
+static SCR_TL ScrStreamTick *scr_st_head = NULL;
+static SCR_TL ScrStreamTick *scr_st_tail = NULL;
 
 static void scr_stream_dispatch_one(void);
 
@@ -512,7 +512,7 @@ static void *scr_stream_rbuf_take(ScrStreamState *st, size_t n) {
     ScrBytes *head = st->r.buf[0];
     size_t avail = head->len - st->r.head_off;
     size_t take = avail < n - at ? avail : n - at;
-    memcpy(out->data + at, head->data + st->r.head_off, take);
+    scr_bytes_read(head, st->r.head_off, out->data + at, take);
     at += take;
     st->r.head_off += take;
     if (st->r.head_off == head->len) {
@@ -2544,7 +2544,7 @@ ScrStream *scr_stream_set_encoding(ScrStream *s, ScrStr *enc) {
     ScrBytes *view = chunk;
     if (i == 0 && skip > 0) {
       view = scr_bytes_new(SCR_BYTES_U8, (double)(chunk->len - skip));
-      memcpy(view->data, chunk->data + skip, chunk->len - skip);
+      scr_bytes_read(chunk, skip, view->data, chunk->len - skip);
     }
     ScrStr *piece = scr_strdec_write(st->r.enc, st->r.dec_pending, view);
     st->r.dec_pending = scr_strdec_next(st->r.enc, st->r.dec_pending, view);