Documentation

Sparkle.Core.JIT

source
opaque Sparkle.Core.JIT.JITHandle.nonemptyType :
NonemptyType

Opaque handle to a loaded JIT shared library

source
def Sparkle.Core.JIT.JITHandle :
Type
Equations
Instances For
    source
    instance Sparkle.Core.JIT.instNonemptyJITHandle :
    Nonempty JITHandle
    source
    @[extern sparkle_jit_load]
    opaque Sparkle.Core.JIT.JIT.load (path : String) :
    IO JITHandle

    Load a compiled JIT shared library (.dylib/.so)

    source
    @[extern sparkle_jit_eval]
    opaque Sparkle.Core.JIT.JIT.eval (h : JITHandle) :
    IO Unit

    Evaluate combinational logic (compute next state)

    source
    @[extern sparkle_jit_tick]
    opaque Sparkle.Core.JIT.JIT.tick (h : JITHandle) :
    IO Unit

    Advance clock (apply next state to registers)

    source
    @[extern sparkle_jit_eval_tick]
    opaque Sparkle.Core.JIT.JIT.evalTick (h : JITHandle) :
    IO Unit

    Fused eval+tick: evaluate combinational logic and advance clock in one call. Register next-state values are kept as local variables instead of class members, eliminating ~260 intermediate memory operations per cycle.

    source
    @[extern sparkle_jit_reset]
    opaque Sparkle.Core.JIT.JIT.reset (h : JITHandle) :
    IO Unit

    Reset all registers to initial values

    source
    @[extern sparkle_jit_destroy]
    opaque Sparkle.Core.JIT.JIT.destroy (h : JITHandle) :
    IO Unit

    Destroy the simulation instance (also runs automatically on finalize)

    source
    @[extern sparkle_jit_set_input]
    opaque Sparkle.Core.JIT.JIT.setInput (h : JITHandle) (portIdx : UInt32) (value : UInt64) :
    IO Unit

    Set an input port by index

    source
    @[extern sparkle_jit_get_output]
    opaque Sparkle.Core.JIT.JIT.getOutput (h : JITHandle) (portIdx : UInt32) :
    IO UInt64

    Get an output port value by index

    source
    @[extern sparkle_jit_get_wire]
    opaque Sparkle.Core.JIT.JIT.getWire (h : JITHandle) (wireIdx : UInt32) :
    IO UInt64

    Get an internal wire value by index (gen* named wires)

    source
    @[extern sparkle_jit_set_mem]
    opaque Sparkle.Core.JIT.JIT.setMem (h : JITHandle) (memIdx addr data : UInt32) :
    IO Unit

    Set a memory word by memory index and address

    source
    @[extern sparkle_jit_get_mem]
    opaque Sparkle.Core.JIT.JIT.getMem (h : JITHandle) (memIdx addr : UInt32) :
    IO UInt32

    Get a memory word by memory index and address

    source
    @[extern sparkle_jit_memset_word]
    opaque Sparkle.Core.JIT.JIT.memsetWord (h : JITHandle) (memIdx addr val count : UInt32) :
    IO Unit

    Fill a range of memory words with a value (bulk write)

    source
    @[extern sparkle_jit_snapshot]
    opaque Sparkle.Core.JIT.JIT.snapshot (h : JITHandle) :
    IO UInt64

    Take a full snapshot of the simulation state (registers + memories). Returns an opaque pointer (as UInt64) that can be passed to restore/freeSnapshot.

    source
    @[extern sparkle_jit_restore]
    opaque Sparkle.Core.JIT.JIT.restore (h : JITHandle) (snap : UInt64) :
    IO Unit

    Restore simulation state from a snapshot taken by JIT.snapshot.

    source
    @[extern sparkle_jit_free_snapshot]
    opaque Sparkle.Core.JIT.JIT.freeSnapshot (h : JITHandle) (snap : UInt64) :
    IO Unit

    Free a snapshot created by JIT.snapshot. Must be called to avoid memory leaks.

    source
    @[extern sparkle_jit_wire_name]
    opaque Sparkle.Core.JIT.JIT.wireName (h : JITHandle) (wireIdx : UInt32) :
    IO String

    Get the name of a wire by index (for discovery)

    source
    @[extern sparkle_jit_num_wires]
    opaque Sparkle.Core.JIT.JIT.numWires (h : JITHandle) :
    IO UInt32

    Get the total number of observable wires

    source
    def Sparkle.Core.JIT.JIT.findWire (h : JITHandle) (name : String) :
    IO (Option UInt32)

    Find a wire index by name, returns none if not found

    Equations
    • One or more equations did not get rendered due to their size.
    Instances For
      source
      @[extern sparkle_jit_set_reg]
      opaque Sparkle.Core.JIT.JIT.setReg (h : JITHandle) (regIdx : UInt32) (value : UInt64) :
      IO Unit

      Set a register value by index (writes current state, not _next)

      source
      @[extern sparkle_jit_get_reg]
      opaque Sparkle.Core.JIT.JIT.getReg (h : JITHandle) (regIdx : UInt32) :
      IO UInt64

      Get a register value by index

      source
      @[extern sparkle_jit_reg_name]
      opaque Sparkle.Core.JIT.JIT.regName (h : JITHandle) (regIdx : UInt32) :
      IO String

      Get the name of a register by index (for discovery)

      source
      @[extern sparkle_jit_num_regs]
      opaque Sparkle.Core.JIT.JIT.numRegs (h : JITHandle) :
      IO UInt32

      Get the total number of registers

      source
      def Sparkle.Core.JIT.JIT.findReg (h : JITHandle) (name : String) :
      IO (Option UInt32)

      Find a register index by name, returns none if not found

      Equations
      • One or more equations did not get rendered due to their size.
      Instances For
        source
        @[extern sparkle_jit_run_cdc]
        opaque Sparkle.Core.JIT.JIT.runCDC (handleA handleB : JITHandle) (cyclesA cyclesB : UInt64) (outPortA inPortB : UInt32) :
        IO (UInt64 × UInt64 × UInt64)

        Run two JIT domains connected via a lock-free SPSC queue (CDC).

        Domain A (producer) runs cyclesA eval_tick cycles, sending output port values to Domain B via the queue. Domain B (consumer) runs cyclesB eval_tick cycles, receiving values and applying them to its input port. Timestamp inversions trigger automatic rollback via snapshot/restore.

        Returns (messagesSent, messagesReceived, rollbackCount).

        source
        def Sparkle.Core.JIT.JIT.compile (cppPath : String) (cacheDir : String := ".lake/build/jit_cache") :
        IO String

        Compile a JIT .c (or legacy .cpp) source file to a shared library, with hash-based caching.

        The CSim backend emits pure C — we use cc and -std=c11, and drop libstdc++/libgcc static-linking entirely (the .so has no C++ dependency). We still pin the JIT .so's runtime linker to the host libc (Issue #70) as defence in depth.

        The input path's extension is accepted as .c, .cpp, or .cc for backward compatibility with existing callers that have historical _jit.c literal paths; the file contents are pure C either way.

        Equations
        • One or more equations did not get rendered due to their size.
        Instances For
          source
          def Sparkle.Core.JIT.JIT.compileAndLoad (cppPath : String) :
          IO JITHandle

          Compile and load a JIT module in one step

          Equations
          Instances For