Allow returning values from proxied functions

[allsey87]

This is an alternative C++ wrapper that I created that allows values to be returned. It uses the same trick as the existing wrapper but instead of erasing a std::function, it erases a std::packaged_task. Perhaps this approach could be integrated into the existing C++ wrapper?

Note that std::invoke_result is only available in C++17 onwards...

class Proxy {
  em_proxying_queue* queue;
  pthread_t runtime_thread;

  template <class T>
  static void run(void* erased_task) {
    auto* task = reinterpret_cast<std::packaged_task<T()>*>(erased_task);
    (*task)();
  }

public:
  Proxy():
    queue(em_proxying_queue_create()),
    runtime_thread(emscripten_main_runtime_thread_id()) {}

  ~Proxy() {
    em_proxying_queue_destroy(queue);
  }

  template <class F, typename... Args>
  auto execute(F&& fn, Args&&... args) -> typename std::invoke_result<F, Args...>::type {
    using Ret = typename std::invoke_result<F, Args...>::type;      
    auto fn_bound = std::bind(std::forward<F>(fn), std::forward<Args>(args)...);
    std::packaged_task<Ret()> task(fn_bound);
    auto future = task.get_future();
    emscripten_proxy_sync(queue, runtime_thread, run<Ret>, reinterpret_cast<void*>(&task));
    return future.get();
  }
};

I then use it like this:

Proxy* p = new Proxy();
p->execute(emscripten_console_log, "hello world111!");
auto x = p->execute(fabsf, -42.0);
std::cout << x << std::endl;
delete p;

[sbc100]

@tlively

[tlively]

Very cool! Would we be able to use std::packaged_task to make a version of ProxyQueue::proxySync that returns the result, do you think?

We also have a similar utility to bundle a proxying queue and worker thread together here. That seems to be a common use case, so perhaps we could add public utilities that help with that, although I see that your wrapper always proxies to the main thread instead.

[allsey87]

Would we be able to use std::packaged_task to make a version of ProxyQueue::proxySync that returns the result, do you think?

Something like this should work (partially tested) and as a bonus std::invoke_result is no longer needed and I think it might even be backwards compatible with the current API...

template <class R>
R proxySync(const pthread_t target, std::function<R()>& fn) {
    std::packaged_task<R()> task(fn);
    auto future = task.get_future();
    emscripten_proxy_sync(queue, target, run<R>, reinterpret_cast<void*>(&task));
    return future.get();
}

I see that your wrapper always proxies to the main thread instead

Indeed, just copied this code from my project for the first example.

[allsey87]

A small catch with this is if you pass a closure to it (instead of a std::function) you need to name the return type in the call's template parameters (it will not be inferred it seems).

myProxy->proxySync<int>(someThread, [] { return 42; });