uasyncio: improve memory footprint

mzdaniel · mzdaniel · commit 279487e9cd3a · 2016-12-25T16:57:13.000-08:00
diff --git a/uasyncio.core/uasyncio/core.py b/uasyncio.core/uasyncio/core.py
@@ -2,22 +2,7 @@
     import utime as time
 except ImportError:
     import time
-try:
-    from utimeq import utimeq
-except ImportError:
-    class utimeq(object):
-        # Simple utimeq drop-in
-        _q = list()
-        def __new__(cls, len=128):
-            self = super(utimeq, cls).__new__(cls)
-            self.__dict__ = None  # Garbage collect unneeded instance dict
-            return self
-        def push(self, *args):
-            self._q.append(args)
-        def pop(self, l):
-            l[:] = list(self._q.pop(0))
-        def __len__(self):
-            return len(self._q)
+import utimeq
 import logging
 
 
@@ -27,10 +12,10 @@ def __len__(self):
 
 type_gen = type((lambda: (yield))())
 
-
 class EventLoop:
+
     def __init__(self, len=128):
-        self.q = utimeq(len)
+        self.q = utimeq.utimeq(len)
 
     def time(self):
         return time.ticks_ms()
@@ -99,23 +84,23 @@ def run_forever(self):
                     if __debug__ and DEBUG:
                         log.debug("Coroutine %s yield result: %s", cb, ret)
                     if isinstance(ret, SysCall1):
-                        sock = ret.arg
+                        arg = ret.arg
                         if isinstance(ret, Sleep):
                             delay = int(arg * 1000)
                         elif isinstance(ret, IORead):
 #                            self.add_reader(ret.obj.fileno(), lambda self, c, f: self.call_soon(c, f), self, cb, ret.obj)
 #                            self.add_reader(ret.obj.fileno(), lambda c, f: self.call_soon(c, f), cb, ret.obj)
 #                            self.add_reader(arg.fileno(), lambda cb: self.call_soon(cb), cb)
-                            self.add_reader(sock, cb)
+                            self.add_reader(arg, cb)
                             continue
                         elif isinstance(ret, IOWrite):
 #                            self.add_writer(arg.fileno(), lambda cb: self.call_soon(cb), cb)
-                            self.add_writer(sock, cb)
+                            self.add_writer(arg, cb)
                             continue
                         elif isinstance(ret, IOReadDone):
-                            self.remove_reader(sock)
+                            self.remove_reader(arg)
                         elif isinstance(ret, IOWriteDone):
-                            self.remove_writer(sock)
+                            self.remove_writer(arg)
                         elif isinstance(ret, StopLoop):
                             return arg
                     elif isinstance(ret, type_gen):
diff --git a/uasyncio/uasyncio/__init__.py b/uasyncio/uasyncio/__init__.py
@@ -4,64 +4,53 @@
 from uasyncio.core import *
 from sys import platform
 
-class ObjMap(dict):
-    @staticmethod
-    def sock_fd(sock_ref):
-        # Compute socket file descriptor replacement for esp8266
-        # sock_ref is a fd in most systems. esp8266 uses sockets instead
-        if isinstance(sock_ref, int):
-            return sock_ref
-        return sock_ref.fileno() if platform != 'esp8266' else id(sock_ref)
-    def __getitem__(self, key):
-        return super().__getitem__(self.sock_fd(key))
-    def __setitem__(self, key, value):
-        super().__setitem__(self.sock_fd(key), value)
-    def __delitem__(self, key):
-        return super().__delitem__(self.sock_fd(key))
-    def __contains__(self, key):
-        return True if self.sock_fd(key) in self.keys() else False
+def sock_fd(sock_ref):
+    # Compute socket file descriptor replacement for esp8266
+    # sock_ref is a fd in most systems. esp8266 uses sockets instead
+    if isinstance(sock_ref, int):
+        return sock_ref
+    return sock_ref.fileno() if platform != 'esp8266' else id(sock_ref)
 
 
 class EpollEventLoop(EventLoop):
 
     def __init__(self):
         EventLoop.__init__(self)
         self.poller = select.poll()
-        self.objmap = ObjMap()
+        self.objmap = {}
 
     def add_reader(self, fd, cb, *args):
         if __debug__:
             log.debug("add_reader%s", (fd, cb, args))
         if args:
             self.poller.register(fd, select.POLLIN)
-            self.objmap[fd] = (cb, args)
+            self.objmap[sock_fd(fd)] = (cb, args)
         else:
             self.poller.register(fd, select.POLLIN)
-            self.objmap[fd] = cb
+            self.objmap[sock_fd(fd)] = cb
 
     def remove_reader(self, fd):
         if __debug__:
             log.debug("remove_reader(%s)", fd)
         self.poller.unregister(fd)
-        del self.objmap[fd]
+        del self.objmap[sock_fd(fd)]
 
     def add_writer(self, fd, cb, *args):
         if __debug__:
             log.debug("add_writer%s", (fd, cb, args))
         if args:
             self.poller.register(fd, select.POLLOUT)
-            self.objmap[fd] = (cb, args)
+            self.objmap[sock_fd(fd)] = (cb, args)
         else:
             self.poller.register(fd, select.POLLOUT)
-            self.objmap[fd] = cb
+            self.objmap[sock_fd(fd)] = cb
 
     def remove_writer(self, fd):
         if __debug__:
             log.debug("remove_writer(%s)", fd)
         try:
             self.poller.unregister(fd)
-            if fd in self.objmap:
-                del self.objmap[fd]
+            self.objmap.pop(sock_fd(fd), None)
         except OSError as e:
             # StreamWriter.awrite() first tries to write to an fd,
             # and if that succeeds, yield IOWrite may never be called
@@ -80,7 +69,7 @@ def wait(self, delay):
             res = self.poller.poll(delay, 1)
         #log.debug("epoll result: %s", res)
         for fd, ev in res:
-            cb = self.objmap[fd]
+            cb = self.objmap[sock_fd(fd)]
             if __debug__:
                 log.debug("Calling IO callback: %r", cb)
             if isinstance(cb, tuple):
