visaljs 0.0.8 → 0.0.10

package/runtime/src/shape.c

@@ -119,6 +119,35 @@ static void roots_put(JSShape **table, size_t cap, JSShape *s) {
     table[i] = s;
 }
 
+/* Removes root `s`, which is in the table. Linear probing: later entries of its probe run move back
+ * into the hole, so that every lookup still finds them. */
+static void roots_remove(JSShapeRegistry *r, const JSShape *s) {
+    size_t mask = r->root_cap - 1, i = root_hash(s->cls, s->proto, s->inline_cap) & mask;
+    while (r->roots[i] != s) i = (i + 1) & mask;
+    r->roots[i] = NULL;
+    r->root_count--;
+    for (size_t j = (i + 1) & mask; r->roots[j]; j = (j + 1) & mask) {
+        JSShape *x = r->roots[j];
+        size_t home = root_hash(x->cls, x->proto, x->inline_cap) & mask;
+        bool stays = i <= j ? (i < home && home <= j) : (i < home || home <= j);
+        if (!stays) {
+            r->roots[i] = x;
+            r->roots[j] = NULL;
+            i = j;
+        }
+    }
+}
+
+/* A shape made since the last collection: a young collection checks it. */
+static void note_young(JSShapeRegistry *r, JSShape *s) {
+    if (r->young_count == r->young_cap) {
+        r->young_cap = r->young_cap ? r->young_cap * 2 : 256;
+        r->young = realloc(r->young, r->young_cap * sizeof *r->young);
+        if (!r->young) js_fatal("out of memory (shape registry)");
+    }
+    r->young[r->young_count++] = s;
+}
+
 static void roots_rebuild(JSShapeRegistry *r, size_t cap, bool (*keep)(JSShape *)) {
     JSShape **table = calloc(cap, sizeof *table);
     if (!table) js_fatal("out of memory (shape roots)");
@@ -152,6 +181,7 @@ JSShape *js_shape_root(JSContext *ctx, const JSClass *cls, JSValue proto, uint16
     if (2 * (r->root_count + 1) > r->root_cap) roots_rebuild(r, r->root_cap ? r->root_cap * 2 : 64, NULL);
     roots_put(r->roots, r->root_cap, s);
     r->root_count++;
+    note_young(r, s);
     return s;
 }
 
@@ -196,6 +226,7 @@ JSShape *js_shape_add(JSContext *ctx, JSShape *shape, JSValue key, uint8_t attrs
         if (!t->items) js_fatal("out of memory (transitions)");
     }
     t->items[t->count++] = (JSTransition){ key, attrs, child };
+    note_young(&ctx->rt->shapes, child);
     return child;
 }
 
@@ -239,8 +270,42 @@ JSPropTable *js_shape_entries(JSShape *s) {
 
 static bool shape_alive(JSShape *s) { return js_gc_is_marked(&s->cell); }
 
-void js_shapes_sweep(JSRuntime *rt) {
+/* A young collection: an old shape stays marked until a full collection, so only the shapes made
+ * since the last collection can be dead. A dead root leaves the roots table; a dead child leaves
+ * its parent's transitions (an emptied table stays, for the next full collection to free); a dead
+ * parent, made since the last collection too, leaves the tail of `parents`. */
+static void sweep_young(JSShapeRegistry *r) {
+    for (size_t i = 0; i < r->young_count; i++) {
+        JSShape *s = r->young[i];
+        if (shape_alive(s)) continue;
+        if (!s->parent) {
+            roots_remove(r, s);
+            continue;
+        }
+        JSShape *p = s->parent;
+        if (!shape_alive(p)) continue;  /* its transitions are freed with it */
+        JSTransitions *t = p->transitions;
+        for (uint32_t k = 0; k < t->count; k++)
+            if (t->items[k].child == s) {
+                t->items[k] = t->items[--t->count];
+                break;
+            }
+    }
+    size_t kept = r->old_parents;
+    for (size_t i = r->old_parents; i < r->parent_count; i++)
+        if (shape_alive(r->parents[i])) r->parents[kept++] = r->parents[i];
+    r->parent_count = kept;
+}
+
+void js_shapes_sweep(JSRuntime *rt, bool full) {
     JSShapeRegistry *r = &rt->shapes;
+    if (!full) {
+        sweep_young(r);
+        r->young_count = 0;
+        r->old_parents = r->parent_count;
+        return;
+    }
+    r->young_count = 0;
     /* a dead parent's children are dead too: they point to it */
     size_t kept = 0;
     for (size_t i = 0; i < r->parent_count; i++) {
@@ -259,6 +324,7 @@ void js_shapes_sweep(JSRuntime *rt) {
         }
     }
     r->parent_count = kept;
+    r->old_parents = kept;
     if (r->root_cap) {
         size_t live = 0;
         for (size_t i = 0; i < r->root_cap; i++) live += r->roots[i] && shape_alive(r->roots[i]);
@@ -271,6 +337,7 @@ void js_shapes_sweep(JSRuntime *rt) {
 void js_shapes_free(JSRuntime *rt) {
     free(rt->shapes.roots);
     free(rt->shapes.parents);
+    free(rt->shapes.young);
     memset(&rt->shapes, 0, sizeof rt->shapes);
 }
 

package/runtime/src/typedarray.c

@@ -1234,6 +1234,26 @@ static double hook_typed_array_length(JSValue v) {
     return out_of_bounds(as_ta(v)) ? -1 : (double)ta_length(as_ta(v));
 }
 
+/* An element the core may read or write inline: of a typed array, a valid index (§10.4.5.15
+ * IsValidIntegerIndex), a Number element. Its own data property: no prototype, no code runs. */
+static bool inline_elem(JSValue v, int32_t i) {
+    if (!is_ta(v) || i < 0) return false;
+    const JSTypedArray *ta = as_ta(v);
+    return !is_bigint_type(ta->type) && (size_t)i < ta_length(ta);
+}
+
+static bool hook_typed_array_get(JSValue v, int32_t i, JSValue *out) {
+    if (!inline_elem(v, i)) return false;
+    *out = js_number(load_number(as_ta(v), (size_t)i));
+    return true;
+}
+
+static bool hook_typed_array_set(JSValue v, int32_t i, double d) {
+    if (!inline_elem(v, i) || immutable(as_ta(v))) return false;
+    store(as_ta(v), (size_t)i, d);
+    return true;
+}
+
 static bool hook_view_bytes(JSValue v, uint8_t **data, size_t *length) {
     return !js_is_array_buffer(v) && js_buffer_source_bytes(v, data, length);
 }
@@ -1330,6 +1350,9 @@ static void install_typedarray(JSContext *ctx, JSObject *global) {
     ctx->rt->is_typed_array = hook_is_typed_array;
     ctx->rt->typed_array_length = hook_typed_array_length;
     ctx->rt->view_bytes = hook_view_bytes;
+    ctx->rt->typed_array_get = hook_typed_array_get;
+    ctx->rt->typed_array_class = &ta_class;
+    ctx->rt->typed_array_set = hook_typed_array_set;
 }
 
 const JSComponent js_component_typedarray = { "typedarray", install_typedarray };

package/runtime/src/weak.c

@@ -61,6 +61,8 @@ typedef struct WeakTable {
     JSObject   obj;
     WeakEntry *entries;  /* malloc'd, the heap's external memory; NULL until the first key */
     uint32_t   cap, count, used;  /* used: count + tombstones */
+    uint32_t   writes;       /* entries set since the last collection, listed in rt->weak_writes */
+    bool       all_written;  /* too many to list: a young collection looks at every entry */
 } WeakTable;
 
 static uint32_t hash_key(JSValue k) {
@@ -83,7 +85,27 @@ static void insert_fresh(WeakEntry *entries, uint32_t cap, JSValue key, JSValue
     entries[i] = (WeakEntry){ key, value };
 }
 
+/* Lists an entry set since the last collection. An entry set before has an old key and an old
+ * value (the last collection marked both, or dropped the entry), so a young collection can't free
+ * either: it looks only at the listed ones (js_weak_ephemerons, js_weak_sweep). Past a quarter of
+ * the table, the table is listed whole instead, which bounds the list. */
+static void note_write(JSRuntime *rt, WeakTable *t, JSValue key) {
+    if (t->all_written) return;
+    if (t->writes >= 64 && t->writes >= t->count / 4) {
+        t->all_written = true;
+        key = JS_EMPTY;
+    }
+    t->writes++;
+    struct JSWeakWrites *l = &rt->weak_writes;
+    if (l->count == l->cap) {
+        l->cap = l->cap ? l->cap * 2 : 64;
+        l->items = xrealloc(l->items, l->cap * sizeof *l->items);
+    }
+    l->items[l->count++] = (struct JSWeakWrite){ &t->obj, key };
+}
+
 static void table_set(JSContext *ctx, WeakTable *t, JSValue key, JSValue value) {
+    note_write(ctx->rt, t, key);
     WeakEntry *e = find(t, key);
     if (e) {
         e->value = value;  /* malloc'd memory: no write barrier */
@@ -392,27 +414,83 @@ int js_run_finalization_cleanups(JSContext *ctx) {
 
 /* ---- The collector's side (gc.c) ------------------------------------------------------- */
 
-/* The ephemeron pass: marks the value of every live WeakMap entry whose key is marked.
- * true if anything new was marked (the caller drains and calls again). */
-bool js_weak_ephemerons(JSRuntime *rt, JSTracer *trc) {
+/* An entry's ephemeron step: its value marked when its key is. Returns whether it marked it. */
+static bool mark_value(JSTracer *trc, const WeakEntry *e) {
+    if (!js_is_cell(e->key) || !js_gc_is_marked(js_as_cell(e->key)) || is_live(e->value)) return false;
+    js_trace_value(trc, e->value);
+    return true;
+}
+
+static bool mark_values(JSTracer *trc, const WeakTable *t) {
     bool marked = false;
-    for (size_t i = 0; i < rt->weak.count; i++) {
-        JSObject *o = rt->weak.items[i];
-        if (o->shape->cls != &weak_map_class || !js_gc_is_marked(&o->cell)) continue;
-        WeakTable *t = (WeakTable *)o;
-        for (uint32_t k = 0; k < t->cap; k++) {
-            WeakEntry *e = &t->entries[k];
-            if (!js_is_cell(e->key) || !js_gc_is_marked(js_as_cell(e->key)) || is_live(e->value)) continue;
-            js_trace_value(trc, e->value);
-            marked = true;
+    for (uint32_t k = 0; k < t->cap; k++) marked |= mark_value(trc, &t->entries[k]);
+    return marked;
+}
+
+/* Drops the entry if its key died. */
+static void sweep_entry(WeakTable *t, WeakEntry *e) {
+    if (js_is_cell(e->key) && !js_gc_is_marked(js_as_cell(e->key))) {
+        e->key = TOMBSTONE;
+        e->value = JS_UNDEFINED;
+        t->count--;
+    }
+}
+
+static void sweep_entries(WeakTable *t) {
+    for (uint32_t k = 0; k < t->cap; k++) sweep_entry(t, &t->entries[k]);
+}
+
+/* The ephemeron pass: marks the value of every live WeakMap entry whose key is marked; a young
+ * collection, of the entries set since the last collection (note_write). true if anything new was
+ * marked (the caller drains and calls again). */
+bool js_weak_ephemerons(JSRuntime *rt, JSTracer *trc, bool full) {
+    bool marked = false;
+    if (full) {
+        for (size_t i = 0; i < rt->weak.count; i++) {
+            JSObject *o = rt->weak.items[i];
+            if (o->shape->cls == &weak_map_class && js_gc_is_marked(&o->cell)) marked |= mark_values(trc, (WeakTable *)o);
+        }
+        return marked;
+    }
+    for (size_t i = 0; i < rt->weak_writes.count; i++) {
+        struct JSWeakWrite w = rt->weak_writes.items[i];
+        if (w.table->shape->cls != &weak_map_class || !js_gc_is_marked(&w.table->cell)) continue;
+        WeakTable *t = (WeakTable *)w.table;
+        if (js_is_empty(w.key)) {
+            marked |= mark_values(trc, t);
+        } else {
+            WeakEntry *e = find(t, w.key);
+            if (e) marked |= mark_value(trc, e);
         }
     }
     return marked;
 }
 
-/* After marking: forget dead containers, drop dead keys, clear dead WeakRef targets, and
- * queue the registrations whose target died. */
-void js_weak_sweep(JSRuntime *rt) {
+/* After marking: forget dead containers, drop dead keys (a young collection: of the entries set
+ * since the last collection), clear dead WeakRef targets, and queue the registrations whose
+ * target died. Then the list of entries set starts anew. */
+void js_weak_sweep(JSRuntime *rt, bool full) {
+    struct JSWeakWrites *writes = &rt->weak_writes;
+    if (!full) {
+        for (size_t i = 0; i < writes->count; i++) {
+            struct JSWeakWrite w = writes->items[i];
+            if (!js_gc_is_marked(&w.table->cell)) continue;  /* dead: its entries go with it */
+            WeakTable *t = (WeakTable *)w.table;
+            if (js_is_empty(w.key)) {
+                sweep_entries(t);
+            } else {
+                WeakEntry *e = find(t, w.key);
+                if (e) sweep_entry(t, e);
+            }
+        }
+    }
+    for (size_t i = 0; i < writes->count; i++) {  /* dead tables too: they're finalized later */
+        WeakTable *t = (WeakTable *)writes->items[i].table;
+        t->writes = 0;
+        t->all_written = false;
+    }
+    writes->count = 0;
+
     struct JSWeakList *l = &rt->weak;
     size_t n = 0;
     for (size_t i = 0; i < l->count; i++) {
@@ -421,15 +499,7 @@ void js_weak_sweep(JSRuntime *rt) {
         l->items[n++] = o;
         const JSClass *cls = o->shape->cls;
         if (cls == &weak_map_class || cls == &weak_set_class) {
-            WeakTable *t = (WeakTable *)o;
-            for (uint32_t k = 0; k < t->cap; k++) {
-                WeakEntry *e = &t->entries[k];
-                if (js_is_cell(e->key) && !js_gc_is_marked(js_as_cell(e->key))) {
-                    e->key = TOMBSTONE;
-                    e->value = JS_UNDEFINED;
-                    t->count--;
-                }
-            }
+            if (full) sweep_entries((WeakTable *)o);
         } else if (cls == &weak_ref_class) {
             WeakRef *w = (WeakRef *)o;
             if (!is_live(w->target)) w->target = JS_UNDEFINED;
@@ -454,6 +524,7 @@ void js_weak_trace_roots(JSRuntime *rt, JSTracer *trc) {
 
 void js_weak_free(JSRuntime *rt) {
     free(rt->weak.items);
+    free(rt->weak_writes.items);
     free(rt->kept_alive.items);
 }