mirror of
https://github.com/denoland/deno.git
synced 2024-12-22 07:14:47 -05:00
dd8cbf5e29
Fixes #22995. Fixes #23000. There were a handful of bugs here causing the hang (each with a corresponding minimized test): - We were canceling recv futures when `receiveMessageOnPort` was called, but this caused the "receive loop" in the message port to exit. This was due to the fact that `CancelHandle`s are never reset (i.e., once you `cancel` a `CancelHandle`, it remains cancelled). That meant that after `receieveMessageOnPort` was called, the subsequent calls to `op_message_port_recv_message` would throw `Interrupted` exceptions, and we would exit the loop. The cancellation, however, isn't actually necessary. `op_message_port_recv_message` only borrows the underlying port for long enough to poll the receiver, so the borrow there could never overlap with `op_message_port_recv_message_sync`. - Calling `MessagePort.unref()` caused the "receive loop" in the message port to exit. This was because we were setting `messageEventListenerCount` to 0 on unref. Not only does that break the counter when multiple `MessagePort`s are present in the same thread, but we also exited the "receive loop" whenever the listener count was 0. I assume this was to prevent the recv promise from keeping the event loop open. Instead of this, I chose to just unref the recv promise as needed to control the event loop. - The last bug causing the hang (which was a doozy to debug) ended up being an unfortunate interaction between how we implement our messageport "receive loop" and a pattern found in `npm:piscina` (which angular uses). The gist of it is that piscina uses an atomic wait loop along with `receiveMessageOnPort` in its worker threads, and as the worker is getting started, the following incredibly convoluted series of events occurs: 1. Parent sends a MessagePort `p` to worker 2. Parent sends a message `m` to the port `p` 3. Parent notifies the worker with `Atomics.notify` that a new message is available 4. Worker receives message, adds "message" listener to port `p` 5. Adding the listener triggers `MessagePort.start()` on `p` 6. Receive loop in MessagePort.start receives the message `m`, but then hits an await point and yields (before dispatching the "message" event) 7. Worker continues execution, starts the atomic wait loop, and immediately receives the existing notification from the parent that a message is available 8. Worker attempts to receive the new message `m` with `receiveMessageOnPort`, but this returns `undefined` because the receive loop already took the message in 6 9. Atomic wait loop continues to next iteration, waiting for the next message with `Atomic.wait` 10. `Atomic.wait` blocks the worker thread, which prevents the receive loop from continuing and dispatching the "message" event for the received message 11. The parent waits for the worker to respond to the first message, and waits 12. The thread can't make any more progress, and the whole process hangs The fix I've chosen here (which I don't particularly love, but it works) is to just delay the `MessagePort.start` call until the end of the event loop turn, so that the atomic wait loop receives the message first. This prevents the hang. --- Those were the main issues causing the hang. There ended up being a few other small bugs as well, namely `exit` being emitted multiple times, and not patching up the message port when it's received by `receiveMessageOnPort`. |
||
|---|---|---|
| .. | ||
| 01_errors.js | ||
| 01_version.ts | ||
| 06_util.js | ||
| 10_permissions.js | ||
| 11_workers.js | ||
| 30_os.js | ||
| 40_fs_events.js | ||
| 40_process.js | ||
| 40_signals.js | ||
| 40_tty.js | ||
| 41_prompt.js | ||
| 90_deno_ns.js | ||
| 98_global_scope_shared.js | ||
| 98_global_scope_window.js | ||
| 98_global_scope_worker.js | ||
| 99_main.js | ||
| README.md | ||
Runtime JavaScript Code
This directory contains Deno runtime code written in plain JavaScript.
Each file is an ES module and is prefixed with a number, telling in which order scripts should be loaded into V8 isolate.
Deno Web APIs
This directory facilities Web APIs that are available in Deno.
Please note, that some implementations might not be completely aligned with specification.
Some Web APIs are using ops under the hood, eg. console, performance.
Implemented Web APIs
- Blob: for representing opaque binary data.
- Console: for logging purposes.
- CustomEvent,
EventTarget
and
EventListener:
to work with DOM events.
- Implementation notes: There is no DOM hierarchy in Deno, so there is no tree for Events to bubble/capture through.
- fetch, Request, Response, Body and Headers: modern Promise-based HTTP Request API.
- location and Location.
- FormData: access
to a
multipart/form-dataserialization. - Performance: retrieving current time with a high precision.
- setTimeout, setInterval, clearTimeout: scheduling callbacks in future and clearInterval.
- Stream for creating, composing, and consuming streams of data.
- URL and URLSearchParams: to construct and parse URLSs.
- Worker: executing
additional code in a separate thread.
- Implementation notes: Blob URLs are not supported, object ownership cannot be transferred, posted data is serialized to JSON instead of structured cloning.