Buffer sequential transport.write calls into one uv_write call

This increases throughput ~100% when many small writes are issued.

Author: 1st1

tests/test_tcp.py

@@ -497,7 +497,57 @@ async def start_server():
 
 
 class Test_UV_TCP(_TestTCP, tb.UVTestCase):
-    pass
+
+    def test_many_small_writes(self):
+        N = 10000
+        TOTAL = 0
+
+        fut = self.loop.create_future()
+
+        async def server(reader, writer):
+            nonlocal TOTAL
+            while True:
+                d = await reader.read(10000)
+                if not d:
+                    break
+                TOTAL += len(d)
+            fut.set_result(True)
+            writer.close()
+
+        async def run():
+            srv = await asyncio.start_server(
+                server,
+                '127.0.0.1', 0,
+                family=socket.AF_INET,
+                loop=self.loop)
+
+            addr = srv.sockets[0].getsockname()
+            r, w = await asyncio.open_connection(*addr, loop=self.loop)
+
+            DATA = b'x' * 102400
+
+            for _ in range(N):
+                w.write(DATA)
+
+                try:
+                    w.write('a')
+                except TypeError:
+                    pass
+
+            await w.drain()
+            for _ in range(N):
+                w.write(DATA)
+                await w.drain()
+
+            w.close()
+            await fut
+
+            srv.close()
+            await srv.wait_closed()
+
+            self.assertEqual(TOTAL, N * 2 * len(DATA))
+
+        self.loop.run_until_complete(run())
 
 
 class Test_AIO_TCP(_TestTCP, tb.AIOTestCase):

uvloop/handles/check.pxd

@@ -0,0 +1,14 @@
+cdef class UVCheck(UVHandle):
+    cdef:
+        Handle h
+        bint running
+
+    # All "inline" methods are final
+
+    cdef _init(self, Loop loop, Handle h)
+
+    cdef inline stop(self)
+    cdef inline start(self)
+
+    @staticmethod
+    cdef UVCheck new(Loop loop, Handle h)

uvloop/handles/check.pyx

@@ -0,0 +1,71 @@
+@cython.no_gc_clear
+cdef class UVCheck(UVHandle):
+    cdef _init(self, Loop loop, Handle h):
+        cdef int err
+
+        self._start_init(loop)
+
+        self._handle = <uv.uv_handle_t*> \
+                            PyMem_Malloc(sizeof(uv.uv_check_t))
+        if self._handle is NULL:
+            self._abort_init()
+            raise MemoryError()
+
+        err = uv.uv_check_init(self._loop.uvloop, <uv.uv_check_t*>self._handle)
+        if err < 0:
+            self._abort_init()
+            raise convert_error(err)
+
+        self._finish_init()
+
+        self.h = h
+        self.running = 0
+
+    cdef inline stop(self):
+        cdef int err
+
+        if not self._is_alive():
+            self.running = 0
+            return
+
+        if self.running == 1:
+            err = uv.uv_check_stop(<uv.uv_check_t*>self._handle)
+            self.running = 0
+            if err < 0:
+                exc = convert_error(err)
+                self._fatal_error(exc, True)
+                return
+
+    cdef inline start(self):
+        cdef int err
+
+        self._ensure_alive()
+
+        if self.running == 0:
+            err = uv.uv_check_start(<uv.uv_check_t*>self._handle,
+                                    cb_check_callback)
+            if err < 0:
+                exc = convert_error(err)
+                self._fatal_error(exc, True)
+                return
+            self.running = 1
+
+    @staticmethod
+    cdef UVCheck new(Loop loop, Handle h):
+        cdef UVCheck handle
+        handle = UVCheck.__new__(UVCheck)
+        handle._init(loop, h)
+        return handle
+
+
+cdef void cb_check_callback(uv.uv_check_t* handle) with gil:
+    if __ensure_handle_data(<uv.uv_handle_t*>handle, "UVCheck callback") == 0:
+        return
+
+    cdef:
+        UVCheck check = <UVCheck> handle.data
+        Handle h = check.h
+    try:
+        h._run()
+    except BaseException as ex:
+        check._error(ex, False)

uvloop/handles/stream.pxd

@@ -5,12 +5,16 @@ cdef class UVStream(UVBaseTransport):
         bint __reading
         bint __read_error_close
         bint _eof
+        list _buffer
+        size_t _buffer_size
 
     # All "inline" methods are final
 
     cdef inline _init(self, Loop loop, object protocol, Server server,
                       object waiter)
 
+    cdef inline _exec_write(self)
+
     cdef inline _shutdown(self)
     cdef inline _accept(self, UVStream server)