Is there any way to have concurrency with function calling on one isolate?

[vmg-dev]

Js is async with an eventloop so in theory you could call async functions and they should run concurrently? Is that possible with rusty script?

[rscarson]

Asynchronous javascript should work fine in rustyscript

Is there a specific issue you had with it?

[vmg-dev]

Yes, I meant a JS promise, sorry for the confusion I realize async function was ambiguous. Specifically I want to be able to call any number of js promises concurrently using the same JsRuntime from Rust. If you have time I'd appreciate it but if you also give me an outline of how it can be done using the runtime and the function globals I can take a stab at it myself

[rscarson]

Seems there is a V8::Promise
I'll likely need to wrap it like I've done for JsFunction

[rscarson]

Yeah so I'll need to avoid finishing polling the event loop, and instead return the future from deno_core::JsRuntime::resolve, with a deserialization step injected

[vmg-dev]

I'm very new to deno core and v8 so here is my guess as to how it could work.
The function below with_event_loop_promise is halfway what I want combined with deno_core::JsRuntime::resolve.

So I think what it needs is

1. The ability to poll multiple promises at once
2. The ability to interrupt the polling to add new promises to be polled. ie it could also wait on a channel that contains the details for the new function to be called
3. Then it needs to restart the polling
4. If a function completes while polling it should use a channel to send back the value of the completed promise
5. if no futures are running it should just wait on the channel for a function to be called

I think the above emulates a "server-like" event loop. Would like your thoughts on the general approach and if you think there are any obvious flaws with it

  /// A utility function that run provided future concurrently with the event loop.
  ///
  /// If the event loop resolves while polling the future, it return an error with the text
  /// `Promise resolution is still pending but the event loop has already resolved.`
  pub async fn with_event_loop_promise<'fut, T, E>(
    &mut self,
    mut fut: impl Future<Output = Result<T, E>> + Unpin + 'fut,
    poll_options: PollEventLoopOptions,
  ) -> Result<T, AnyError>
  where
    AnyError: From<E>,
  {
    // Manually implement tokio::select
    poll_fn(|cx| {
      if let Poll::Ready(t) = fut.poll_unpin(cx) {
        return Poll::Ready(t.map_err(|e| e.into()));
      }
      if let Poll::Ready(t) = self.poll_event_loop(cx, poll_options) {
        t?;
        if let Poll::Ready(t) = fut.poll_unpin(cx) {
          return Poll::Ready(t.map_err(|e| e.into()));
        }
        return Poll::Ready(Err(anyhow!("Promise resolution is still pending but the event loop has already resolved.")));
      }
      Poll::Pending
    }).await
  }

[rscarson]

The 0.5.0 release will add an async API with the notable absense of concurrent promise exports

I have a few ideas for this and have opened a tracking issue

[rscarson]

Js is async with an eventloop so in theory you could call async functions and they should run concurrently? Is that possible with rusty script?

Ok so 0.5.0 is releasing sometime tomorrow, if all goes well

It massively increases support for asynchronous and multithreaded usecases

HOWEVER, unfortunately since a JS runtime is always singlethreaded by design, multithreaded applications normally use threaded workers, each with a seperate runtime

0.5.0 adds some support for this, in the new worker module. This featureset is a WIP and will be extended in the near future