sci.impl.world — org.replikativ/sci 0.15.59-replikativ.1

Dense, fork-local runtime state for SCI contexts.

Stable handles are assigned integer slots once per context lineage. A world stores slot values densely and a frozen fork copies that array while the source world is quiescent. Mutable primitives CAS only their own slot, so unrelated atoms never contend on a shared world root.

absent clj/s

active-ctx clj/s

(active-ctx captured)

Use the currently evaluating descendant context for an interpreted closure. Unrelated SCI contexts cannot capture one another accidentally.

active-world-state clj/s

(active-world-state)

alter-namespace-meta! clj/s

(alter-namespace-meta! handle fallback f args)

alter-type-data! clj/s

(alter-type-data! handle fallback f args)

alter-var-meta! clj/s

(alter-var-meta! handle fallback f args)

alter-var-watches! clj/s

(alter-var-watches! handle fallback f args)

attach-managed-owner! clj/s

(attach-managed-owner! registry managed-index owner)

Attach weak ownership after constructing a self-described handle. The owner is never retained strongly by the lineage registry.

binding-scope clj/s

(binding-scope)

Return the currently executing world for dynamic-binding isolation. Nil denotes a host binding established outside managed SCI evaluation.

call-with-context clj/s

(call-with-context ctx f)

Run f with ctx installed as both SCI's dynamic context and active world. This is the host invocation boundary for interpreted values that outlive the top-level evaluation which produced them.

call-with-var-context clj/s

(call-with-var-context handle f)

Run f in the active related world for handle, or in the Var's stable home world when invoked directly by the host. Shared built-in Vars have no home and retain their direct compatibility behavior.

compare-and-set-tracked! clj/s

(compare-and-set-tracked! handle expected new validate! notify!)

current-world clj/s

(current-world)

fork-world clj/s

(fork-world world fork-value snapshot-value snapshot-var-meta)

IWorldTracked clj/s protocol

-mark-world-tracked! clj/s

(-mark-world-tracked! handle home-ctx)

-world-home-ctx clj/s

(-world-home-ctx handle)

-world-tracked? clj/s

(-world-tracked? handle)

managed-assoc! clj/s

(managed-assoc! home registry slot k value)

Associate one key in a managed persistent-map slot without the generic callback/validation path. Used by mutable SCI deftype fields.

managed-compare-and-set! clj/s

(managed-compare-and-set! home registry slot expected new validate! notify!)

(managed-compare-and-set! home
                          registry
                          slot
                          expected
                          new
                          validate!
                          notify!
                          coordination)

(managed-compare-and-set! home
                          registry
                          slot
                          expected
                          new
                          validate!
                          notify!
                          coordination
                          validation-current?)

managed-reset! clj/s

(managed-reset! home registry slot new validate! notify!)

(managed-reset! home registry slot new validate! notify! coordination)

(managed-reset! home
                registry
                slot
                new
                validate!
                notify!
                coordination
                validation-current?)

managed-swap! clj/s

(managed-swap! home registry slot f args validate! notify!)

(managed-swap! home registry slot f args validate! notify! coordination)

(managed-swap! home
               registry
               slot
               f
               args
               validate!
               notify!
               coordination
               validation-current?)

CAS a directly described slot. The logical fallback represents a slot allocated in another branch but not yet realized in the selected world.

managed-update-control-with-value! clj/s

(managed-update-control-with-value! home
                                    registry
                                    value-slot
                                    control-slot
                                    coordination
                                    validate-value!
                                    update-control)

Atomically validate the selected value and update a related control slot. coordination must be the same stable handle used by value commits.

managed-value clj/s

(managed-value home registry slot)

Read a self-described managed slot in the active related world, falling back to the owner's creation world outside managed evaluation.

managed-value-in clj/s

(managed-value-in world home slot)

Read a managed slot from an already selected world.

mutable-primary-world? clj/s

(mutable-primary-world?)

namespace-meta clj/s

(namespace-meta handle fallback)

new-world clj/s

(new-world)

primary-world? clj/s

(primary-world?)

read-world clj/s

(read-world world primary?)

register! clj/s

(register! handle value)

(register! handle value value-fork-fn)

register-managed! clj/s

(register-managed! kind values fork-indexes)

Allocate dense slots whose owner carries the returned descriptor directly. Managed descriptors contain no owner reference, so an unreachable SCI ref is not retained by the lineage registry. fork-indexes names values that need host Forkable/:fork-fn processing when a child world is copied.

register-namespace! clj/s

(register-namespace! handle m)

register-type! clj/s

(register-type! handle data)

(register-type! handle data value-fork-fn)

register-var! clj/s

(register-var! handle value m)

(register-var! handle value m watches)

registered? clj/s

(registered? world handle)

reset-namespace-meta! clj/s

(reset-namespace-meta! handle m)

reset-tracked! clj/s

(reset-tracked! handle new validate! notify!)

reset-type-data! clj/s

(reset-type-data! handle data)

reset-value! clj/s

(reset-value! handle value)

reset-var-meta! clj/s

(reset-var-meta! handle m)

slot-of clj/s

(slot-of world handle)

Return the value slot assigned to handle, or nil when it is not registered in this lineage. Intended for analyzer-time resolution.

swap-value! clj/s

(swap-value! handle f args validate! notify!)

Atomically update one tracked slot. Unrelated SCI atoms do not contend and cannot cause f to be retried.

tracked? clj/s

(tracked? handle)

type-data clj/s

(type-data handle fallback)

value clj/s

(value handle fallback)

var-meta clj/s

(var-meta handle fallback)

var-value clj/s

(var-value handle fallback)

Primary contexts retain their direct Var realization. Descendants resolve the stable Var handle through its dense lineage slot.

var-value-at clj/s

(var-value-at slot fallback)

Read a Var through a slot already resolved by the analyzer.

var-watches clj/s

(var-watches handle fallback)

with-active-world clj/s

(with-active-world ctx f)

Run f with the context's world installed. On the JVM evaluations take a shared gate permit; a fork takes the exclusive permit and therefore observes a quiescent source world without adding locks to individual reads.