asyncify | Do n't keep your promises | Reactive Programming library

I have this function "IsBrave" in my main.cpp.
If browser contains navigator.brave it calls the navigator.brave.isBrave() function with await.

But when call from browser's console the exported function, it prints undefined value instead of "Brave" on Brave browser. In other browsers result is "Unknown".

Tested in Brave Browser's Console

Emscripten's old Emterpreter mode had a setting EMTERPRETIFY_ADVISE that would output which functions it had identified needed to be converted for use with the Emterpreter.

In the new Asyncify mode, how can I get a similar list of functions which had to be instrumented/handled with Asyncify? I've checked the docs and settings.js, but couldn't see anything like EMTERPRETIFY_ADVISE.

Everything I can find about performance of Amazon Simple Queue Service (SQS), including their own documentation, suggests that getting high throughput requires multiple threads. And I've verified this myself using the JS API with Node 12. If I create multiple threads, I get about the same throughput on each thread, so the total throughput increase is pretty much linear. But I'm running this on a nice machine with lots of cores. When I run in Lambda on a single core, multiple threads don't improve the performance, and generally this is what I would expect of multi-threaded apps.

But here's what I don't understand - there should be very little going on here in the way of CPU, most of the time is spent waiting on web requests. The AWS SQS API appears to be asynchronous in that all of the methods use callbacks for the responses, and I'm using Promises to "asyncify" all of the API calls, with multiple tasks running concurrently. Normally doing this with any kind of async IO is handled great by Node, and improves throughput hugely, I do it all the time with database APIs, multiple streams, etc. But SQS definitely isn't behaving that way, it's behaving as though its IO is actually synchronous and blocking threads on the network calls, which would be outrageous for any modern API.

Has anyone had success getting high SQS message throughput in a single Node thread? The max I'm seeing is about 50 to 100 messages/sec for FIFO queues (send, receive, and delete, all of which are calling the batch methods with the max batch size of 10). And this is running in lambda, i.e. on their own network, which is only slightly faster than running it on my laptop over the Internet, another surprising find. Amazon's documentation says FIFO queues should support up to 3000 messages per second when batching, which would be just fine for me. Does it really take multiple threads on multiple cores or virtual CPUs to achieve this? That would be ridiculous, I just can't believe that much CPU would be used, it should be mostly IO time, which should be asynchronous.

Edit:

As I continued to test, I found that the linear improvement with the number of threads only happened when each thread was processing a different queue. If the threads are all processing the same queue, there is no improvement by adding threads. So it behaves as though each queue is throttled by Amazon. But the throughput to which it seems to be throttling is way below what I found documented as the max throughput. Really confused and disappointed right now!

I was breaking down some code I found. I got stuck on a specific issue and managed to break it down into a smaller piece. Just keep in mind that this code is part of a much bigger piece of code.

I am trying to find a general solution for offloading blocking tasks to a ThreadPoolExecutor.

In the example below, I can achieve the desired non-blocking result in the NonBlockingHandler using Tornado's run_on_executor decorator.

In the asyncify decorator, I am trying to accomplish the same thing, but it blocks other calls.

Any ideas how to get the asyncify decorator to work correctly and not cause the decorated function to block?

NOTE: I am using Python 3.6.8 and Tornado 4.5.3

Here is the full working example:

I am trying to use router middleware to get the value of req.route. I have some simple code like this:

server.js

Suppose I have a function that takes a generator and returns another generator of the first n elements:

Question about asynchronsousity

I've wrote 2 node express servers both running on localhost.

Server1 has a simple express REST API that receives GET requests from browser, this API will trigger a GET request to Server2, while the request (sent from Server1) is wrapped within a NodeJS async library call. Server2 will respond for each request after 10 seconds (using the good old node's setTimeout).

My thinking was that - If 2 requests sent from Server1 to Server2 (one second after the other) what would happend is:

1. Server1 will send the first request to Server2 and will not wait for response, making the event loop available to listen to more incoming requests.

2. After 1 second 2nd request comes in and Server1 will shoot out this one as well to Server2.

3. Server2 will count 10 seconds for each incoming request, which eventually will respond also with ~1 second delay between the responses to Server1.

4. Server1 will respond eventually to both request after ~11 seconds (responses to browser).

BUT NOT !!!

What I get is:

The response to browser for the 1st request is received after 10 seconds.
The response to browser for the 2nd request is received after another 10 seconds counted from the first response (making it ~20 seconds in total) as if no async mechanism is working at all.

(And by the way I tried to wrap the request that Server1 sends with async.asyncify(...), async.series(...), async.parallel(...) - 2nd request always comes back after ~20 seconds).

Why?

My severs code:

Server 1: gets both requests to localhost:9999/work1

So i am using this guide to learn about async-ish behavior in JS. The example i am unable to wrap my head around is this