Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-js

Source of release 0.6.1

0.6.1 / src / host / worker_pipes.lucb

#==============================================================================================
#
#   worker_pipes - Message pipes between a worker and its parent, and shared array buffers
#
#   DESCRIPTION:
#       Port of quickjs-libc.c lines 2278-2418 (JSWaker, handle_posted_message)
#       and 3478-3587 (the reference-counted SharedArrayBuffer allocator, the message
#       pipes, their messages and the message ports). A pipe is a queue of serialized
#       messages guarded by a mutex (`sync.Mutex` for pthread_mutex_t); its waker is a
#       POSIX pipe whose read end is readable while the queue is not empty, so that
#       js_os_poll waits for messages with poll() beside the file descriptors; on Windows
#       it is an event object js_os_poll waits for with WaitForMultipleObjects. A pipe is
#       shared by two threads and freed by the last one to drop it; a SharedArrayBuffer's
#       storage likewise, whatever runtime it is referenced from.
#
#==============================================================================================

# mark: Wakers ==================================================================================

func js_waker_init(w: Waker*) -> i32:
    if platform.windows:
        w.handle = CreateEventA(none, 1, 0, none)
        return 0 if w.handle != none else -1
    else:
        var fds: i32[2] = [0, 0]
        if pipe(&fds[0]) < 0:
            return -1
        w.read_fd = fds[0]
        w.write_fd = fds[1]
        return 0

func js_waker_signal(w: Waker*):
    if platform.windows:
        _ = SetEvent(w.handle)
    else:
        var byte: u8 = 0
        while true:
            let ret = write(w.write_fd, &byte, 1)
            if ret == 1:
                break
            # as in C, whose test (errno != EAGAIN || errno != EINTR) is always true: any
            # failure stops
            if ret < 0 and (c.errno() != e_again or c.errno() != e_intr):
                break

func js_waker_clear(w: Waker*):
    if platform.windows:
        _ = ResetEvent(w.handle)
    else:
        var buf: u8[16] = ---
        while true:
            let ret = read(w.read_fd, &buf[0], 16)
            if ret >= 0:
                break
            let err = c.errno()
            if err != e_again and err != e_intr:
                break

func js_waker_close(w: Waker*):
    if platform.windows:
        _ = CloseHandle(w.handle)
        w.handle = invalid_handle_value()
    else:
        _ = close(w.read_fd)
        _ = close(w.write_fd)
        w.read_fd = -1
        w.write_fd = -1

# mark: Receiving messages ======================================================================

## The message whose queue link is `el`.
func worker_message_of(el: ListHead*) -> WorkerMessage*:
    return (WorkerMessage*)((u8*)el - memory.offset_of(WorkerMessage, link))

## The message port whose list link is `el`.
func message_handler_of(el: ListHead*) -> WorkerMessageHandler*:
    return (WorkerMessageHandler*)((u8*)el - memory.offset_of(WorkerMessageHandler, link))

## return 1 if a message was handled, 0 if no message
func handle_posted_message(rt: Runtime*, ctx: Context*, port: WorkerMessageHandler*) -> i32:
    let ps = port.recv_pipe else return 0
    ps.mutex.lock()
    if cutils.list_empty(&ps.msg_queue):
        ps.mutex.unlock()
        return 0
    let el = ps.msg_queue.next else trap("handle_posted_message: unlinked queue")
    let msg = worker_message_of(el)

    # remove the message from the queue
    cutils.list_del(&msg.link)

    if cutils.list_empty(&ps.msg_queue):
        js_waker_clear(&ps.waker)

    ps.mutex.unlock()

    var failed = false
    let data = msg.data else trap("handle_posted_message: message without data")
    let data_obj = js.js_read_object(ctx, data, msg.data_len, js.read_obj_sab | js.read_obj_reference) catch:
        failed = true
        recover js.js_undefined()

    js_free_message(msg)

    if failed:
        js_std_dump_error(ctx)
    else:
        call_on_message(ctx, port, data_obj) catch: js_std_dump_error(ctx)
    return 1

## Call the onmessage handler of `port` with an event `{ data: data_obj }`; takes
## `data_obj`.
func call_on_message(ctx: Context*, port: WorkerMessageHandler*, data_obj: Value) -> !:
    var obj = js.js_new_object(ctx) catch failure:
        js.js_free_value(ctx, data_obj)
        error(failure.code, failure.message)
    defer js.js_free_value(ctx, obj)
    _ = js.js_define_property_value_str(ctx, obj, "data", data_obj, js.prop_c_w_e) catch: recover false

    # 'func' might be destroyed when calling itself (if it frees the handler), so must
    # take extra care
    let func_ = js.js_dup_value(ctx, port.on_message_func)
    defer js.js_free_value(ctx, func_)
    let retval = try js.js_call(ctx, func_, js.js_undefined(), 1, &obj)
    js.js_free_value(ctx, retval)

# mark: SharedArrayBuffer allocator =============================================================

## The header before the storage of a SharedArrayBuffer (JSSABHeader); the storage
## (`uint64_t buf[0]`) starts 8-byte aligned after it.
align(8) struct SABHeader:
    var ref_count: @i32

## Add `v` to the atomic `*ptr` and answer the new value (atomic_add_int).
func atomic_add_int(ptr: (@i32)*, v: i32) -> i32:
    return ptr.add(v) +% v

## The header of the SharedArrayBuffer storage `ptr`.
func sab_header_of(ptr: void*?) -> SABHeader*:
    let p = ptr else trap("host: SharedArrayBuffer without storage")
    return (SABHeader*)((u8*)p - memory.size_of(SABHeader))

# shared array buffer allocator
func js_sab_alloc(opaque: void*?, size: usize) -> void*?:
    let block = cutils.malloc(memory.size_of(SABHeader) + size) else return none
    let sab = (SABHeader*)block
    sab.ref_count = 1
    return (u8*)block + memory.size_of(SABHeader)

func js_sab_free(opaque: void*?, ptr: void*?):
    let sab = sab_header_of(ptr)
    let ref_count = atomic_add_int(&sab.ref_count, -1)
    assert(ref_count >= 0)
    if ref_count == 0:
        cutils.c_free(sab)

func js_sab_dup(opaque: void*?, ptr: void*?):
    let sab = sab_header_of(ptr)
    _ = atomic_add_int(&sab.ref_count, 1)

# mark: Message pipes ===========================================================================

func js_new_message_pipe() -> WorkerMessagePipe*?:
    let block = cutils.malloc(memory.size_of(WorkerMessagePipe)) else return none
    let ps = (WorkerMessagePipe*)block
    if js_waker_init(&ps.waker) != 0:
        cutils.c_free(ps)
        return none
    ps.ref_count = 1
    cutils.init_list_head(&ps.msg_queue)
    ps.mutex = sync.Mutex()
    return ps

func js_dup_message_pipe(ps: WorkerMessagePipe*) -> WorkerMessagePipe*:
    _ = atomic_add_int(&ps.ref_count, 1)
    return ps

func js_free_message(msg: WorkerMessage*):
    # free the SAB
    if let sab_tab = msg.sab_tab:
        for i in 0..<msg.sab_tab_len:
            js_sab_free(none, sab_tab[i])
    cutils.c_free(msg.sab_tab)
    cutils.c_free(msg.data)
    cutils.c_free(msg)

func js_free_message_pipe(pipe_or_none: WorkerMessagePipe*?):
    let ps = pipe_or_none else return

    let ref_count = atomic_add_int(&ps.ref_count, -1)
    assert(ref_count >= 0)
    if ref_count == 0:
        var el = ps.msg_queue.next else trap("js_free_message_pipe: unlinked queue")
        while el != &ps.msg_queue:
            let el1 = el.next else trap("js_free_message_pipe: unlinked queue")
            js_free_message(worker_message_of(el))
            el = el1
        js_waker_close(&ps.waker)
        cutils.c_free(ps)

func js_free_port(rt: Runtime*, port_or_none: WorkerMessageHandler*?):
    let port = port_or_none else return
    js_free_message_pipe(port.recv_pipe)
    js.js_free_value_rt(rt, port.on_message_func)
    if port.link.prev != none:
        cutils.list_del(&port.link)
    js.js_free_rt(rt, port)