Ability to sleep / suspend thread

[trucidare]

Hey everybody,

i ran into in issue with the wasmtime runtime.
Looping to keep the program running causes 100% on one core.
Any chance to get a delay(ms: Number) function to avoid this?

[ospencer]

Hey @trucidare!

Sleeping a thread is one of those things that needs help from a system call to work properly—that thread would need to request that the manager of that thread suspend it for some amount of time before continuing (i.e., have a wasm host that supports this functionality).

WASI doesn't have a sleep functionality, but you could implement a sleep by busy-waiting a certain duration of time, maybe even including a call to sched_yield to allow other processes to run. That won't solve the high CPU usage, though.

Does that make sense?

[trucidare]

Hmpf, sched_yield will only put the thread at the end of the handled thread list but since we live in a multi core era this will not really do anything.

It could be possible to use poll_oneoff and ignore some events to achive a sleep but i dont know how to implement the mostly inherited structs needed there.

https://github.com/bytecodealliance/wasmtime/blob/main/crates/wasi-common/src/snapshots/preview_1.rs#L896

[trucidare]

Tried to implement it myself but i dont know if its correct done. Two scenarios to get the struct build but not working at all.
The cpu utilization is 0% but it halted with this.
Hopefully anyone can fix this

// https://docs.rs/wasi/0.10.0+wasi-snapshot-preview1/wasi/fn.poll_oneoff.html

import foreign wasm poll_oneoff: (
  WasmI32, /*in*/
  WasmI32, /*out*/
  WasmI32, /*n*/
  WasmI32
) -> WasmI32 from "wasi_snapshot_preview1";


let _EVT_CLOCK = 0n
let _EVT_FDREAD = 1n
let _EVT_FDWROTE = 2n

let _SUB_ABSTIME = 1n

let _CLOCK_REALTIME = 0n
let _CLOCK_MOOTONIC = 1n
let _CLOCK_PROCESS_CPUTIME_ID = 2n
let _CLOCK_THREAD_CPUTIME_ID = 3n

record SubscriptionFdReadWrite {
  file_descriptor: Int32
}

record SubscriptionClock {
  id: WasmI32,
  timeout: Int64,
  precision: Int64,
  flags: Bytes 
}

record SubscriptionUU {
  clock: SubscriptionClock,
  fd_read: SubscriptionFdReadWrite,
  fd_write: SubscriptionFdReadWrite
}

record SubscriptionU {
  tag: Bytes, // u8
  u: SubscriptionUU
}

record Subscription {
  userdata: Int64,
  u: SubscriptionU
}

record EventFdReadWrite {
  nbytes: Int64,
  flags: Bytes
}

record Event {
  userdata: Int64,
  errno: Bytes,
  eventtype: Bytes,
  fd_readwrite: EventFdReadWrite
}


@unsafe
export let sleep = (ms: Number) => {
  if (1 == 1) {
 
    let clockSub = {
      userdata: 0L,
      u: {
        tag: Bytes.make(1), 
        u: {
          clock: {
            id: _CLOCK_REALTIME,
            timeout: Int64.fromNumber(ms),
            precision: 10000L,
            flags: Bytes.make(2) 
          },
          fd_read: {
            file_descriptor: 0l
          },
          fd_write: {
            file_descriptor: 0l
          }
        }
      }
    }

    let clockEvent = {
      userdata: 0L,
      errno: Bytes.make(2),
      eventtype: Bytes.make(1),
      fd_readwrite: {
        nbytes: 0L,
        flags: Bytes.make(2)
      }
    }


    let bufSub = Memory.malloc(39n)
    let bufEvt = Memory.malloc(21n)
    let bufSize = Memory.malloc(4n)


    WasmI32.store(bufSub, WasmI32.fromGrain(clockSub), 0n)
    WasmI32.store(bufEvt, WasmI32.fromGrain(clockEvent), 0n)
    
    let res = poll_oneoff(bufSub, bufEvt, 1n, bufSize)
    print(res)

  } else {

    let clockSub = Buffer.make(0)
      Buffer.addInt64(0L, clockSub)
      Buffer.addInt8(0l,clockSub)
      Buffer.addInt32(WasmI32.toGrain(_CLOCK_REALTIME),clockSub)
      Buffer.addInt64(Int64.fromNumber(ms),clockSub)
      Buffer.addInt64(10000L,clockSub)
      Buffer.addInt16(0l,clockSub)
      Buffer.addInt32(0l,clockSub)
      Buffer.addInt32(0l,clockSub)

    let clockEvent = Buffer.make(0)
      Buffer.addInt64(0L, clockEvent)
      Buffer.addInt16(0l, clockEvent)
      Buffer.addInt8(0l, clockEvent)
      Buffer.addInt64(0L, clockEvent)
      Buffer.addInt16(0l,clockEvent)


    let bufSub = Memory.malloc(WasmI32.fromGrain(Buffer.length(clockSub)))
    let bufEvt = Memory.malloc(WasmI32.fromGrain(Buffer.length(clockEvent)))
    let bufSize = Memory.malloc(4n)

    WasmI32.store(bufSub, WasmI32.fromGrain(clockSub), 0n)
    WasmI32.store(bufEvt, WasmI32.fromGrain(clockEvent), 0n)
    
    let res = poll_oneoff(bufSub, bufEvt, 1n, bufSize)
    print(res)
  }

  void
}

[ospencer]

I implemented events over in #1583, and I was able to write a sleep function:

import Int64 from "int64"
import Result from "result"

import Time from "sys/time"
import Event from "sys/event"

let sleep = ms => {
  let subscription: Event.Subscription = {
    userdata: 0L,
    contents: Event.SubscriptionClock(
      {
        clock: Time.Realtime,
        timeout: Int64.fromNumber(ms * 1_000_000),
        precision: 1000L,
        flags: [],
      }
    ),
  }

  ignore(Result.expect("Sleeping failed", Event.pollOneoff([subscription])))
}

let mut counter = 1

while (true) {
  print(counter)
  sleep(1000)
  counter += 1
}

Running in wasmtime, I get effectively 0% CPU use:

It'll be a while before this lands, but you could use the code in the PR if you needed something working immediately.

[trucidare]

Realy nice to See - thanks - i will use this in my mqtt Broker :)

[ospencer]

I accidentally left it running overnight; can confirm it's still 0% CPU and seemingly no memory leaks 😅

[trucidare]

Yeah cool
My broker with 1.7% for over a day.