lukechilds/node - node - Gitea: Git with a cup of tea

514 Commits

131 Branches

446 Tags

325 MiB

Tree: 9b3e2ae192

Commit Graph

Author	SHA1	Message	Date
Ryan	aefbd57514	Add stack to promise.wait(). The problem was that if promise A was waiting and promise B was created and then also told to wait (from some callback coming off the event loop), and then promise A finished, promise B's wait would return. Promise A's wait would not return until promise B was finished. This is incorrect. To solve this issue properly, one probably needs to allocate separate execution stacks. I use, instead, Poor Man's Coroutines. We continue to use the main execution stack and force promises created most recently to return first. That is even if Promise A finishes first, neither wait() returns. Not until Promise B finishes, will its wait() return. After that is complete, Promise A's wait() will return. This introduces the problem of growing the "wait stack" infinitely. Thus I've added a strong warning to the documentation only to use this operation sparingly. require() and include() seem to be the proper use case for such a thing: they are called usually at program start up - they don't take too long to finish and they won't be called so often. Let's experiment with this stop-gap. If the infinite promise stack becomes a problem for many, then I will remove promise.wait() entirely or perhaps only use it for thread pool events.	15 years ago

Author

SHA1

Message

Date

Ryan

aefbd57514

Add stack to promise.wait().

The problem was that if promise A was waiting and promise B was created and
then also told to wait (from some callback coming off the event loop), and
then promise A finished, promise B's wait would return. Promise A's wait
would not return until promise B was finished. This is incorrect.

To solve this issue properly, one probably needs to allocate separate
execution stacks. I use, instead, Poor Man's Coroutines. We continue to use
the main execution stack and force promises created most recently to return
first.

That is even if Promise A finishes first, neither wait() returns. Not until
Promise B finishes, will its wait() return. After that is complete, Promise
A's wait() will return.

This introduces the problem of growing the "wait stack" infinitely. Thus
I've added a strong warning to the documentation only to use this operation
sparingly. require() and include() seem to be the proper use case for such a
thing: they are called usually at program start up - they don't take too
long to finish and they won't be called so often.

Let's experiment with this stop-gap. If the infinite promise stack becomes a
problem for many, then I will remove promise.wait() entirely or perhaps only
use it for thread pool events.

15 years ago

1 Commits (9b3e2ae192e73f7ecc55e1686965a66c9a0107ff)