whitequark · Nov 29, 2018 · Nov 29, 2018
Showing with 129 additions and 3 deletions.

+125 −0 software/glasgow/support/chunked_fifo.py

+4 −3 software/glasgow/support/pyrepl.py
diff --git a/software/glasgow/support/chunked_fifo.py b/software/glasgow/support/chunked_fifo.py
@@ -0,0 +1,125 @@
+from collections import deque
+
+
+class ChunkedFIFO:
+    """
+    A first-in first-out byte buffer that uses discontiguous storage to operate without copying.
+    """
+    def __init__(self):
+        self._queue  = deque()
+        self._chunk  = None
+        self._offset = 0
+
+    def write(self, data):
+        """Enqueue ``data``."""
+        if not data:
+            return
+
+        self._queue.append(memoryview(data))
+
+    def read(self, max_length=None):
+        """
+        Dequeue at most ``max_length`` bytes. If ``max_length`` is not specified, dequeue
+        the maximum possible contiguous amount of bytes (at least one).
+
+        Regardless of what was written into the FIFO, ``read`` always returns a ``memoryview``
+        object.
+        """
+        if max_length is None and self._chunk is None:
+            # Fast path.
+            return self._queue.popleft()
+
+        if max_length == 0:
+            return memoryview(b"")
+
+        if self._chunk is None:
+            self._chunk = self._queue.popleft()
+            self._offset = 0
+
+        if max_length is None:
+            result = self._chunk[self._offset:]
+        else:
+            result = self._chunk[self._offset:self._offset + max_length]
+
+        if self._offset + len(result) == len(self._chunk):
+            self._chunk = None
+        else:
+            self._offset += len(result)
+
+        return result
+
+    def __bool__(self):
+        return bool(self._queue)
+
+    def __len__(self):
+        length = sum(len(chunk) for chunk in self._queue)
+        if self._chunk is not None:
+            length += len(self._chunk) - self._offset
+        return length
+
+# -------------------------------------------------------------------------------------------------
+
+import unittest
+
+
+class ChunkedFIFOTestCase(unittest.TestCase):
+    def setUp(self):
+        self.fifo = ChunkedFIFO()
+
+    def test_zero_write(self):
+        self.fifo.write(b"")
+        with self.assertRaises(IndexError):
+            self.fifo.read()
+
+    def test_zero_read(self):
+        self.assertEqual(self.fifo.read(0), b"")
+        self.fifo.write(b"A")
+        self.assertEqual(self.fifo.read(0), b"")
+        self.assertEqual(self.fifo.read(), b"A")
+
+    def test_fast(self):
+        self.fifo.write(b"AB")
+        self.fifo.write(b"CD")
+        self.assertEqual(self.fifo.read(), b"AB")
+        self.assertEqual(self.fifo.read(), b"CD")
+
+    def test_chunked(self):
+        self.fifo.write(b"ABCD")
+        self.fifo.write(b"EF")
+        self.assertEqual(self.fifo.read(1), b"A")
+        self.assertEqual(self.fifo.read(1), b"B")
+        self.assertEqual(self.fifo.read(2), b"CD")
+        self.assertEqual(self.fifo.read(), b"EF")
+
+    def test_chunked_chunked(self):
+        self.fifo.write(b"ABCD")
+        self.fifo.write(b"EF")
+        self.assertEqual(self.fifo.read(1), b"A")
+        self.assertEqual(self.fifo.read(1), b"B")
+        self.assertEqual(self.fifo.read(2), b"CD")
+        self.assertEqual(self.fifo.read(1), b"E")
+        self.assertEqual(self.fifo.read(1), b"F")
+
+    def test_chunked_fast(self):
+        self.fifo.write(b"ABCD")
+        self.fifo.write(b"EF")
+        self.assertEqual(self.fifo.read(1), b"A")
+        self.assertEqual(self.fifo.read(1), b"B")
+        self.assertEqual(self.fifo.read(), b"CD")
+        self.assertEqual(self.fifo.read(), b"EF")
+
+    def test_bool(self):
+        self.assertFalse(self.fifo)
+        self.fifo.write(b"A")
+        self.assertTrue(self.fifo)
+
+    def test_len(self):
+        self.assertEqual(len(self.fifo), 0)
+        self.fifo.write(b"ABCD")
+        self.assertEqual(len(self.fifo), 4)
+        self.fifo.write(b"EF")
+        self.assertEqual(len(self.fifo), 6)
+        self.fifo.read(1)
+        self.assertEqual(len(self.fifo), 5)
+        self.fifo.read(3)
+        self.assertEqual(len(self.fifo), 2)
diff --git a/software/glasgow/support/pyrepl.py b/software/glasgow/support/pyrepl.py
@@ -32,9 +32,10 @@ def save_history(self):
     def runcode(self, code):
         try:
             exec(code, self.locals)
-            result = self.locals["__builtins__"]["_"]
-            if asyncio.iscoroutine(result):
-                self._fut = self.locals["__builtins__"]["_"] = asyncio.ensure_future(result)
+            builtins = self.locals["__builtins__"]
+            if "_" in builtins:
+                if asyncio.iscoroutine(builtins["_"]):
+                    self._fut = builtins["_"] = asyncio.ensure_future(builtins["_"])
         except SystemExit:
             raise
         except: