Add a parameter to control the internal queue length

There is no good trade-off here …

Author: smurfix

trio_asyncio/async_.py

@@ -85,7 +85,7 @@ def _close(self):
 
 @asynccontextmanager
 @async_generator
-async def open_loop():
+async def open_loop(queue_len=None):
     """Main entry point: run an asyncio loop on top of Trio.
 
     This is a context manager.
@@ -107,7 +107,7 @@ def _main_loop_exit(self):
 
     async with trio.open_nursery() as nursery:
         old_loop = asyncio.get_event_loop()
-        loop = TrioEventLoop()
+        loop = TrioEventLoop(queue_len=queue_len)
         try:
             loop._closed = False
             asyncio.set_event_loop(loop)

trio_asyncio/base.py

@@ -107,7 +107,13 @@ class BaseTrioEventLoop(asyncio.SelectorEventLoop):
 
     * closed - nothing further may happen
 
+    Arguments:
+        queue_len:
+            The maximum length of the internal event queue.
+            The default is 1000. Use more for large programs,
+            or when running benchmarks.
     """
+
     # for calls from other threads or contexts
     _token = None
 
@@ -127,9 +133,12 @@ class BaseTrioEventLoop(asyncio.SelectorEventLoop):
     # (threading) Thread this loop is running in
     _thread = None
 
-    def __init__(self, close_files=None):
+    def __init__(self, queue_len=None):
+        if queue_len is None:
+            queue_len=1000
+
         # Processing queue
-        self._q = trio.Queue(9999)
+        self._q = trio.Queue(queue_len)
 
         # which files to close?
         self._close_files = set()

trio_asyncio/loop.py

@@ -212,12 +212,12 @@ def run_trio_task(proc, *args):
     loop.run_trio_task(proc, *args)
 
 
-def run(proc, *args):
+def run(proc, *args, queue_len=None):
     """Like :func:`trio.run`, but adds a context that supports asyncio.
     """
 
     async def _run_task(proc, args):
-        async with open_loop():
+        async with open_loop(queue_len=queue_len):
             return await proc(*args)
 
     trio.run(_run_task, proc, args)