Simplify accordint to PR comments, optimize and cleanup

Author: taras

uvloop/handles/stream.pxd

@@ -35,12 +35,12 @@ cdef class UVStream(UVBaseTransport):
     # and then call _initiate_write() to start writing either immediately or in
     # the next iteration (loop._queue_write()).
     cdef inline _buffer_write(self, object data)
-    cdef inline _initiate_write(self, bint skip_fast_path)
+    cdef inline _initiate_write(self)
 
     # _exec_write() is the method that does the actual send, and _try_write()
     # is a fast-path used in _exec_write() to send a single chunk.
-    cdef inline _exec_write(self)
-    cdef inline _try_write(self, object data)
+    cdef inline bint _exec_write(self) except? -1
+    cdef inline Py_ssize_t _try_write(self, object data) except? -2
 
     cdef _close(self)
 

uvloop/handles/stream.pyx

@@ -1,4 +1,4 @@
-cdef enum:
+cdef enum:
     __PREALLOCED_BUFS = 4
 
 
@@ -341,13 +341,13 @@ cdef class UVStream(UVBaseTransport):
         else:
             self.__reading_stopped()
 
-    cdef inline _try_write(self, object data):
+    cdef inline Py_ssize_t _try_write(self, object data) except? -2:
         cdef:
-            ssize_t written
+            Py_ssize_t written
             bint used_buf = 0
             Py_buffer py_buf
             void* buf
-            size_t blen
+            Py_ssize_t blen
             int saved_errno
             int fd
 
@@ -368,6 +368,8 @@ cdef class UVStream(UVBaseTransport):
             blen = py_buf.len
 
         if blen == 0:
+            if used_buf:
+                PyBuffer_Release(&py_buf)
             # Empty data, do nothing.
             return 0
 
@@ -392,24 +394,20 @@ cdef class UVStream(UVBaseTransport):
             PyBuffer_Release(&py_buf)
 
         if written < 0:
-            if saved_errno == errno.EAGAIN or \
-                    saved_errno == system.EWOULDBLOCK:
-                return -1
+            if saved_errno in (errno.EAGAIN, system.EWOULDBLOCK):
+                return 0
             else:
                 exc = convert_error(-saved_errno)
                 self._fatal_error(exc, True)
-                return
+                return -1
 
         if UVLOOP_DEBUG:
             self._loop._debug_stream_write_tries += 1
 
-        if <size_t>written == blen:
-            return 0
-
         return written
 
     cdef inline _buffer_write(self, object data):
-        cdef int dlen
+        cdef Py_ssize_t dlen
 
         if not PyBytes_CheckExact(data):
             data = memoryview(data).cast('b')
@@ -421,22 +419,20 @@ cdef class UVStream(UVBaseTransport):
         self._buffer_size += dlen
         self._buffer.append(data)
 
-    cdef inline _initiate_write(self, bint skip_fast_path):
-        if (not skip_fast_path and
-            not self._protocol_paused and
-            (<uv.uv_stream_t*>self._handle).write_queue_size == 0 and
-            self._buffer_size > self._high_water):
+    cdef inline _initiate_write(self):
+        cdef bint all_sent
+
+        if (not self._protocol_paused and
+            (<uv.uv_stream_t*>self._handle).write_queue_size == 0):
             # Fast-path.  If:
-            #   - the caller hasn't tried fast path itself
             #   - the protocol isn't yet paused,
             #   - there is no data in libuv buffers for this stream,
-            #   - the protocol will be paused if we continue to buffer data
             #
             # Then:
             #   - Try to write all buffered data right now.
             all_sent = self._exec_write()
             if UVLOOP_DEBUG:
-                if self._buffer_size != 0 or self._buffer != []:
+                if self._buffer_size != 0 or self._buffer:
                     raise RuntimeError(
                         '_buffer_size is not 0 after a successful _exec_write')
 
@@ -452,20 +448,21 @@ cdef class UVStream(UVBaseTransport):
             self._maybe_pause_protocol()
             self._loop._queue_write(self)
 
-    cdef inline _exec_write(self):
+    cdef inline bint _exec_write(self) except? -1:
         cdef:
             int err
-            int buf_len
+            Py_ssize_t buf_len
+            Py_ssize_t sent
             _StreamWriteContext ctx = None
 
         if self._closed:
             # If the handle is closed, just return, it's too
             # late to do anything.
-            return
+            return False
 
         buf_len = len(self._buffer)
         if not buf_len:
-            return
+            return True
 
         if (<uv.uv_stream_t*>self._handle).write_queue_size == 0:
             # libuv internal write buffers for this stream are empty.
@@ -475,34 +472,16 @@ cdef class UVStream(UVBaseTransport):
                 data = self._buffer[0]
                 sent = self._try_write(data)
 
-                if sent is None:
-                    # A `self._fatal_error` was called.
-                    # It might not raise an exception under some
-                    # conditions.
-                    self._buffer_size = 0
-                    self._buffer.clear()
-                    if not self._closing:
-                        # This should never happen.
-                        raise RuntimeError(
-                            'stream is open after UVStream._try_write '
-                            'returned None')
-                    return
-
-                if sent == 0:
-                    # All data was successfully written.
+                if sent == len(data):
+                    # The most likely outcome,
+                    # all data was successfully written.
                     self._buffer_size = 0
                     self._buffer.clear()
                     # on_write will call "maybe_resume_protocol".
                     self._on_write()
                     return True
 
-                if sent > 0:
-                    if UVLOOP_DEBUG:
-                        if sent == len(data):
-                            raise RuntimeError(
-                                '_try_write sent all data and returned '
-                                'non-zero')
-
+                elif sent > 0:
                     if PyBytes_CheckExact(data):
                         # Cast bytes to memoryview to avoid copying
                         # data that wasn't sent.
@@ -512,6 +491,19 @@ cdef class UVStream(UVBaseTransport):
                     self._buffer_size -= sent
                     self._buffer[0] = data
 
+                elif sent == -1:
+                    # A `self._fatal_error` was called.
+                    # It might not raise an exception under some
+                    # conditions.
+                    self._buffer_size = 0
+                    self._buffer.clear()
+                    if not self._closing:
+                        # This should never happen.
+                        raise RuntimeError(
+                            'stream is open after UVStream._try_write '
+                            'returned None')
+                    return False
+
                 # At this point it's either data was sent partially,
                 # or an EAGAIN has happened.
 
@@ -545,15 +537,15 @@ cdef class UVStream(UVBaseTransport):
                         self._fatal_error(ex, True)
                         self._buffer.clear()
                         self._buffer_size = 0
-                        return
+                        return False
 
                 elif err != uv.UV_EAGAIN:
                     ctx.close()
                     exc = convert_error(err)
                     self._fatal_error(exc, True)
                     self._buffer.clear()
                     self._buffer_size = 0
-                    return
+                    return False
 
                 # fall through
 
@@ -577,9 +569,10 @@ cdef class UVStream(UVBaseTransport):
 
             exc = convert_error(err)
             self._fatal_error(exc, True)
-            return
+            return False
 
         self._maybe_resume_protocol()
+        return False
 
     cdef size_t _get_write_buffer_size(self):
         if self._handle is NULL:
@@ -684,46 +677,8 @@ cdef class UVStream(UVBaseTransport):
             self._conn_lost += 1
             return
 
-        cdef ssize_t bytes_written
-
-        if self._get_write_buffer_size() == 0:
-            bytes_written_ = self._try_write(buf)
-
-            if bytes_written_ is None:
-                # A `self._fatal_error` was called.
-                # It might not raise an exception under some
-                # conditions.
-                if not self._closing:
-                    raise RuntimeError('stream is open after '
-                                       'UVStream._try_write returned None')
-
-                return
-
-            bytes_written = bytes_written_
-
-            if bytes_written == 0:
-                # All data was successfully written.
-                # on_write will call "maybe_resume_protocol".
-                return
-
-            if bytes_written > 0:
-                if UVLOOP_DEBUG:
-                    if bytes_written == len(buf):
-                        raise RuntimeError('_try_write sent all data and '
-                                           'returned non-zero')
-
-                if PyBytes_CheckExact(buf):
-                    # Cast bytes to memoryview to avoid copying
-                    # data that wasn't sent.
-                    buf = memoryview(buf)
-                buf = buf[bytes_written_:]
-
-            # At this point it's either data was sent partially,
-            # or an EAGAIN has happened.
-            # buffer remaining data and send it later
-
         self._buffer_write(buf)
-        self._initiate_write(True)  # skip fast path in _initiate_write
+        self._initiate_write()
 
     def writelines(self, bufs):
         self._ensure_alive()
@@ -735,7 +690,7 @@ cdef class UVStream(UVBaseTransport):
             return
         for buf in bufs:
             self._buffer_write(buf)
-        self._initiate_write(False) # try fast path in _initiate_write
+        self._initiate_write()
 
     def write_eof(self):
         self._ensure_alive()