Rework SSLStream's receive size handling

Author: njsmith

trio/_ssl.py

@@ -165,9 +165,30 @@
 # SSLStream
 ################################################################
 
-# XX TODO: this number was pulled out of a hat. We should tune it with
-# science.
-DEFAULT_RECEIVE_SIZE = 65536
+# Ideally, when the user calls SSLStream.receive_some() with no argument, then
+# we should do exactly one call to self.transport_stream.receive_some(),
+# decrypt everything we got, and return it. Unfortunately, the way openssl's
+# API works, we have to pick how much data we want to allow when we call
+# read(), and then it (potentially) triggers a call to
+# transport_stream.receive_some(). So at the time we pick the amount of data
+# to decrypt, we don't know how much data we've read. As a simple heuristic,
+# we record the max amount of data returned by previous calls to
+# transport_stream.receive_some(), and we use that for future calls to read().
+# But what do we use for the very first call? That's what this constant sets.
+#
+# Note that the value passed to read() is a limit on the amount of
+# *decrypted* data, but we can only see the size of the *encrypted* data
+# returned by transport_stream.receive_some(). TLS adds a small amount of
+# framing overhead, and TLS compression is rarely used these days because it's
+# insecure. So the size of the encrypted data should be a slight over-estimate
+# of the size of the decrypted data, which is exactly what we want.
+#
+# The specific value is not really based on anything; it might be worth tuning
+# at some point. But, if you have an TCP connection with the typical 1500 byte
+# MTU and an initial window of 10 (see RFC 6928), then the initial burst of
+# data will be limited to ~15000 bytes (or a bit less due to IP-level framing
+# overhead), so this is chosen to be larger than that.
+STARTING_RECEIVE_SIZE = 16384
 
 
 class NeedHandshakeError(Exception):
@@ -342,6 +363,8 @@ def __init__(
             "another task is currently receiving data on this SSLStream"
         )
 
+        self._estimated_receive_size = STARTING_RECEIVE_SIZE
+
     _forwarded = {
         "context",
         "server_side",
@@ -537,6 +560,9 @@ async def _retry(self, fn, *args, ignore_want_read=False):
                         if not data:
                             self._incoming.write_eof()
                         else:
+                            self._estimated_receive_size = max(
+                                self._estimated_receive_size, len(data)
+                            )
                             self._incoming.write(data)
                         self._inner_recv_count += 1
         if not yielded:
@@ -617,10 +643,12 @@ async def receive_some(self, max_bytes=None):
                 else:
                     raise
             if max_bytes is None:
-                # Heuristic: normally we use DEFAULT_RECEIVE_SIZE, but if
-                # the transport gave us a bunch of data last time then we'll
-                # try to decrypt and pass it all back at once.
-                max_bytes = max(DEFAULT_RECEIVE_SIZE, self._incoming.pending)
+                # If we somehow have more data already in our pending buffer
+                # than the estimate receive size, bump up our size a bit for
+                # this read only.
+                max_bytes = max(
+                    self._estimated_receive_size, self._incoming.pending
+                )
             else:
                 max_bytes = _operator.index(max_bytes)
                 if max_bytes < 1: