16

If I'm sending a large Blob or ArrayBuffer over a JavaScript WebSocket via its send method... does the send method call block until the data is sent, or does it make a copy of the data to send asynchronously so the call can return immediately?

A related (unanswered) question is, from how I interpret it, whether a rapid series of sends will cause onmessage events to be delayed, as someone seems to have described happening in Mobile Safari: Apparent blocking behaviour in JavaScript websocket on mobile Safari

Community
  • 1
  • 1
Triynko
  • 18,766
  • 21
  • 107
  • 173

1 Answers1

12

Based on the description of the bufferedAmount attribute, I have deduced that send must return immediately, because otherwise bufferedAmount would always be zero. If it is non-zero, then there must be data buffered from a prior call to send, and if send buffers data, there's no reason for it to block.

From http://dev.w3.org/html5/websockets/

The bufferedAmount attribute must return the number of bytes of application data (UTF-8 text and binary data) that have been queued using send() but that, as of the last time the event loop started executing a task, had not yet been transmitted to the network. (This thus includes any text sent during the execution of the current task, regardless of whether the user agent is able to transmit text asynchronously with script execution.) This does not include framing overhead incurred by the protocol, or buffering done by the operating system or network hardware. If the connection is closed, this attribute's value will only increase with each call to the send() method (the number does not reset to zero once the connection closes).

In this simple example, the bufferedAmount attribute is used to ensure that updates are sent either at the rate of one update every 50ms, if the network can handle that rate, or at whatever rate the network can handle, if that is too fast.

var socket = new WebSocket('ws://game.example.com:12010/updates');
socket.onopen = function () {
    setInterval(function() {
       if (socket.bufferedAmount == 0)
           socket.send(getUpdateData());
    }, 50);
};

The bufferedAmount attribute can also be used to saturate the network without sending the data at a higher rate than the network can handle, though this requires more careful monitoring of the value of the attribute over time.

Triynko
  • 18,766
  • 21
  • 107
  • 173
  • I'm going to see how many votes, if any, this answer gets. It seems that logically, send generally wouldn't have a reason to block, but I have no idea how it will behave with very large Blobs or ArrayBuffers, such as if it was to exceed some maximum allowed buffered amount. The specification says the user agent must close the websocket with predjudice if send is called and the buffer is full. – Triynko Aug 16 '13 at 00:30
  • 1
    Seems there is a 2GB limit in some implementations: "So we might want to mention in our docs that we currently support up to 2 GB Web Socket messages, both incoming/outgoing. That's the theoretical limit--malloc is sure to fail on mobile for such sizes, in which case (as spec mandates) the websocket is failed." - https://bugzilla.mozilla.org/show_bug.cgi?id=711003 – Triynko Aug 16 '13 at 00:42