Windows: Use 32-bit distribution of python

1 files changed, 708 insertions, 1478 deletions

diff --git a/python/gevent/libev/corecext.pyx b/python/gevent/libev/corecext.pyx
index a7fb888..793b002 100644
--- a/python/gevent/libev/corecext.pyx
+++ b/python/gevent/libev/corecext.pyx
@@ -1,14 +1,37 @@
-# Generated by cythonpp.py on 2017-06-05 11:30:19
 # Copyright (c) 2009-2012 Denis Bilenko. See LICENSE for details.
-# This directive, supported in Cython 0.24+, causes sources files to be
-# much smaller and thus cythonpp.py to be slightly faster. But it does make
-# debugging more difficult.
-# cython: emit_code_comments=False
+
+# This first directive, supported in Cython 0.24+, causes sources
+# files to be *much* smaller when it's false (139,027 LOC vs 35,000
+# LOC) and thus cythonpp.py (and probably the compiler; also Visual C
+# has limits on source file sizes) to be faster (73s vs 46s). But it does
+# make debugging more difficult. Auto-pickling was added in 0.26, and
+# that's a new feature that we don't need or want to allow in a gevent
+# point release.
+
+# cython: emit_code_comments=False, auto_pickle=False
+
+# NOTE: We generally cannot use the Cython IF directive as documented
+# at
+# http://cython.readthedocs.io/en/latest/src/userguide/language_basics.html#conditional-compilation
+# (e.g., IF UNAME_SYSNAME == "Windows") because when Cython says
+# "compilation", it means when *Cython* compiles, not when the C
+# compiler compiles. We distribute an sdist with a single pre-compiled
+# C file for all platforms so that end users that don't use a binary
+# wheel don't have to sit through cythonpp and other steps the Makefile does.
+# See https://github.com/gevent/gevent/issues/1076
+
 cimport cython
 cimport libev
-# Note this is not the standard cython 'cpython' (which has a backwards compat alias of 'python')
-# it's our custom def. If it's not on the include path, we get warned.
-from python cimport *
+
+from cpython.ref cimport Py_INCREF
+from cpython.ref cimport Py_DECREF
+from cpython.mem cimport PyMem_Malloc
+from cpython.mem cimport PyMem_Free
+from libc.errno cimport errno
+
+cdef extern from "Python.h":
+    int    Py_ReprEnter(object)
+    void   Py_ReprLeave(object)
 
 # Work around lack of absolute_import in Cython
 # Note for PY3: not doing so will leave reference to locals() on import
@@ -17,6 +40,7 @@ sys = __import__('sys', level=0)
 os = __import__('os', level=0)
 traceback = __import__('traceback', level=0)
 signalmodule = __import__('signal', level=0)
+getswitchinterval = __import__('gevent', level=0).getswitchinterval
 
 
 __all__ = ['get_version',
@@ -51,9 +75,6 @@ cdef extern from "callbacks.h":
     void gevent_call(loop, callback)
     void gevent_noop(libev.ev_loop, void*, int)
 
-cdef extern from *:
-    int errno
-
 cdef extern from "stathelper.c":
     object _pystat_fromstructstat(void*)
 
@@ -232,37 +253,163 @@ def embeddable_backends():
 def time():
     return libev.ev_time()
 
+cdef bint _check_loop(loop loop) except -1:
+    if not loop._ptr:
+        raise ValueError('operation on destroyed loop')
+    return 1
 
 
 
-cdef bint _default_loop_destroyed = False
+cdef public class callback [object PyGeventCallbackObject, type PyGeventCallback_Type]:
+    cdef public object callback
+    cdef public tuple args
+    cdef callback next
 
+    def __init__(self, callback, args):
+        self.callback = callback
+        self.args = args
 
+    def stop(self):
+        self.callback = None
+        self.args = None
 
+    close = stop
 
+    # Note, that __nonzero__ and pending are different
+    # nonzero is used in contexts where we need to know whether to schedule another callback,
+    # so it's true if it's pending or currently running
+    # 'pending' has the same meaning as libev watchers: it is cleared before entering callback
 
+    def __nonzero__(self):
+        # it's nonzero if it's pending or currently executing
+        return self.args is not None
+
+    @property
+    def pending(self):
+        return self.callback is not None
+
+    def __repr__(self):
+        if Py_ReprEnter(self) != 0:
+            return "<...>"
+        try:
+            format = self._format()
+            result = "<%s at 0x%x%s" % (self.__class__.__name__, id(self), format)
+            if self.pending:
+                result += " pending"
+            if self.callback is not None:
+                result += " callback=%r" % (self.callback, )
+            if self.args is not None:
+                result += " args=%r" % (self.args, )
+            if self.callback is None and self.args is None:
+                result += " stopped"
+            return result + ">"
+        finally:
+            Py_ReprLeave(self)
+
+    def _format(self):
+        return ''
+
+DEF CALLBACK_CHECK_COUNT = 50
+
+@cython.final
+@cython.internal
+cdef class CallbackFIFO(object):
+    cdef callback head
+    cdef callback tail
+
+    def __init__(self):
+        self.head = None
+        self.tail = None
+
+    cdef inline callback popleft(self):
+        cdef callback head = self.head
+        self.head = head.next
+        if self.head is self.tail or self.head is None:
+            self.tail = None
+        head.next = None
+        return head
+
+
+    cdef inline append(self, callback new_tail):
+        assert not new_tail.next
+        if self.tail is None:
+            if self.head is None:
+                # Completely empty, so this
+                # is now our head
+                self.head = new_tail
+                return
+            self.tail = self.head
+
+
+        assert self.head is not None
+        old_tail = self.tail
+        old_tail.next = new_tail
+        self.tail = new_tail
+
+    def __nonzero__(self):
+        return self.head is not None
+
+    def __len__(self):
+        cdef Py_ssize_t count = 0
+        head = self.head
+        while head is not None:
+            count += 1
+            head = head.next
+        return count
+
+    def __iter__(self):
+        cdef list objects = []
+        head = self.head
+        while head is not None:
+            objects.append(head)
+            head = head.next
+        return iter(objects)
+
+    cdef bint has_callbacks(self):
+        return self.head
+
+    def __repr__(self):
+        return "<callbacks@%r len=%d head=%r tail=%r>" % (id(self), len(self), self.head, self.tail)
 
 
 cdef public class loop [object PyGeventLoopObject, type PyGeventLoop_Type]:
-    cdef libev.ev_loop* _ptr
-    cdef public object error_handler
+    ## embedded struct members
     cdef libev.ev_prepare _prepare
-    cdef public list _callbacks
     cdef libev.ev_timer _timer0
-#ifdef _WIN32
+    # We'll only actually start this timer if we're on Windows,
+    # but it doesn't hurt to compile it in on all platforms.
     cdef libev.ev_timer _periodic_signal_checker
-#endif
 
-    def __init__(self, object flags=None, object default=None, size_t ptr=0):
+    ## pointer members
+    cdef public object error_handler
+    cdef libev.ev_loop* _ptr
+    cdef public CallbackFIFO _callbacks
+
+    ## data members
+    cdef bint starting_timer_may_update_loop_time
+    # We must capture the 'default' state at initialiaztion
+    # time. Destroying the default loop in libev sets
+    # the libev internal pointer to 0, and ev_is_default_loop will
+    # no longer work.
+    cdef bint _default
+
+    def __cinit__(self, object flags=None, object default=None, libev.intptr_t ptr=0):
+        self.starting_timer_may_update_loop_time = 0
+        self._default = 0
+        libev.ev_prepare_init(&self._prepare,
+                              <void*>gevent_run_callbacks)
+        libev.ev_timer_init(&self._periodic_signal_checker,
+                            <void*>gevent_periodic_signal_check,
+                            0.3, 0.3)
+        libev.ev_timer_init(&self._timer0,
+                            <void*>gevent_noop,
+                            0.0, 0.0)
+
         cdef unsigned int c_flags
         cdef object old_handler = None
-        libev.ev_prepare_init(&self._prepare, <void*>gevent_run_callbacks)
-#ifdef _WIN32
-        libev.ev_timer_init(&self._periodic_signal_checker, <void*>gevent_periodic_signal_check, 0.3, 0.3)
-#endif
-        libev.ev_timer_init(&self._timer0, <void*>gevent_noop, 0.0, 0.0)
         if ptr:
             self._ptr = <libev.ev_loop*>ptr
+            self._default = libev.ev_is_default_loop(self._ptr)
         else:
             c_flags = _flags_to_int(flags)
             _check_flags(c_flags)
@@ -270,88 +417,121 @@ cdef public class loop [object PyGeventLoopObject, type PyGeventLoop_Type]:
             c_flags |= libev.EVFLAG_FORKCHECK
             if default is None:
                 default = True
-                if _default_loop_destroyed:
-                    default = False
             if default:
+                self._default = 1
                 self._ptr = libev.gevent_ev_default_loop(c_flags)
                 if not self._ptr:
                     raise SystemError("ev_default_loop(%s) failed" % (c_flags, ))
-#ifdef _WIN32
-                libev.ev_timer_start(self._ptr, &self._periodic_signal_checker)
-                libev.ev_unref(self._ptr)
-#endif
+                if sys.platform == "win32":
+                    libev.ev_timer_start(self._ptr, &self._periodic_signal_checker)
+                    libev.ev_unref(self._ptr)
             else:
                 self._ptr = libev.ev_loop_new(c_flags)
                 if not self._ptr:
                     raise SystemError("ev_loop_new(%s) failed" % (c_flags, ))
             if default or __SYSERR_CALLBACK is None:
                 set_syserr_cb(self._handle_syserr)
-            libev.ev_prepare_start(self._ptr, &self._prepare)
-            libev.ev_unref(self._ptr)
-        self._callbacks = []
+
+        # Mark as not destroyed
+        libev.ev_set_userdata(self._ptr, self._ptr)
+
+        libev.ev_prepare_start(self._ptr, &self._prepare)
+        libev.ev_unref(self._ptr)
+
+    def __init__(self, object flags=None, object default=None, libev.intptr_t ptr=0):
+        self._callbacks = CallbackFIFO()
 
     cdef _run_callbacks(self):
         cdef callback cb
         cdef object callbacks
-        cdef int count = 1000
-        libev.ev_timer_stop(self._ptr, &self._timer0)
-        while self._callbacks and count > 0:
-            callbacks = self._callbacks
-            self._callbacks = []
-            for cb in callbacks:
+        cdef int count = CALLBACK_CHECK_COUNT
+        self.starting_timer_may_update_loop_time = True
+        cdef libev.ev_tstamp now = libev.ev_now(self._ptr)
+        cdef libev.ev_tstamp expiration = now + <libev.ev_tstamp>getswitchinterval()
+
+        try:
+            libev.ev_timer_stop(self._ptr, &self._timer0)
+            while self._callbacks.head is not None:
+                cb = self._callbacks.popleft()
+
                 libev.ev_unref(self._ptr)
-                gevent_call(self, cb)
+                gevent_call(self, cb) # XXX: Why is this a C callback, not cython?
                 count -= 1
-        if self._callbacks:
-            libev.ev_timer_start(self._ptr, &self._timer0)
 
-    def _stop_watchers(self):
+                if count == 0 and self._callbacks.head is not None:
+                    # We still have more to run but we've reached
+                    # the end of one check group
+                    count = CALLBACK_CHECK_COUNT
+
+                    libev.ev_now_update(self._ptr)
+                    if libev.ev_now(self._ptr) >= expiration:
+                        now = 0
+                        break
+
+            if now != 0:
+                libev.ev_now_update(self._ptr)
+            if self._callbacks.head is not None:
+                libev.ev_timer_start(self._ptr, &self._timer0)
+        finally:
+            self.starting_timer_may_update_loop_time = False
+
+    cdef _stop_watchers(self, libev.ev_loop* ptr):
+        if not ptr:
+            return
+
         if libev.ev_is_active(&self._prepare):
-            libev.ev_ref(self._ptr)
-            libev.ev_prepare_stop(self._ptr, &self._prepare)
-#ifdef _WIN32
+            libev.ev_ref(ptr)
+            libev.ev_prepare_stop(ptr, &self._prepare)
         if libev.ev_is_active(&self._periodic_signal_checker):
-            libev.ev_ref(self._ptr)
-            libev.ev_timer_stop(self._ptr, &self._periodic_signal_checker)
-#endif
+            libev.ev_ref(ptr)
+            libev.ev_timer_stop(ptr, &self._periodic_signal_checker)
 
     def destroy(self):
-        global _default_loop_destroyed
-        if self._ptr:
-            self._stop_watchers()
+        cdef libev.ev_loop* ptr = self._ptr
+        self._ptr = NULL
+
+        if ptr:
+            if not libev.ev_userdata(ptr):
+                # Whoops! Program error. They destroyed the loop,
+                # using a different loop object. Our _ptr is still
+                # valid, but the libev loop is gone. Doing anything
+                # else with it will likely cause a crash.
+                return
+            # Mark as destroyed
+            libev.ev_set_userdata(ptr, NULL)
+            self._stop_watchers(ptr)
             if __SYSERR_CALLBACK == self._handle_syserr:
                 set_syserr_cb(None)
-            if libev.ev_is_default_loop(self._ptr):
-                _default_loop_destroyed = True
-            libev.ev_loop_destroy(self._ptr)
-            self._ptr = NULL
+            libev.ev_loop_destroy(ptr)
 
     def __dealloc__(self):
-        if self._ptr:
-            self._stop_watchers()
-            if not libev.ev_is_default_loop(self._ptr):
-                libev.ev_loop_destroy(self._ptr)
-            self._ptr = NULL
-
-    property ptr:
-
-        def __get__(self):
-            return <size_t>self._ptr
-
-    property WatcherType:
-
-        def __get__(self):
-            return watcher
+        cdef libev.ev_loop* ptr = self._ptr
+        self._ptr = NULL
+        if ptr != NULL:
+            if not libev.ev_userdata(ptr):
+                # See destroy(). This is a bug in the caller.
+                return
+            self._stop_watchers(ptr)
+            if not self._default:
+                libev.ev_loop_destroy(ptr)
+                # Mark as destroyed
+                libev.ev_set_userdata(ptr, NULL)
 
-    property MAXPRI:
+    @property
+    def ptr(self):
+        return <size_t>self._ptr
 
-       def __get__(self):
-           return libev.EV_MAXPRI
+    @property
+    def WatcherType(self):
+        return watcher
 
-    property MINPRI:
+    @property
+    def MAXPRI(self):
+        return libev.EV_MAXPRI
 
-        def __get__(self):
-            return libev.EV_MINPRI
+    @property
+    def MINPRI(self):
+        return libev.EV_MINPRI
 
     def _handle_syserr(self, message, errno):
         if sys.version_info[0] >= 3:
@@ -376,9 +556,7 @@ cdef public class loop [object PyGeventLoopObject, type PyGeventLoop_Type]:
             libev.ev_break(self._ptr, libev.EVBREAK_ONE)
 
     def run(self, nowait=False, once=False):
-        
-        if not self._ptr:
-            raise ValueError('operation on destroyed loop')
+        _check_loop(self)
         cdef unsigned int flags = 0
         if nowait:
             flags |= libev.EVRUN_NOWAIT
@@ -392,103 +570,71 @@ cdef public class loop [object PyGeventLoopObject, type PyGeventLoop_Type]:
             libev.ev_loop_fork(self._ptr)
 
     def ref(self):
-        
-        if not self._ptr:
-            raise ValueError('operation on destroyed loop')
+        _check_loop(self)
         libev.ev_ref(self._ptr)
 
     def unref(self):
-        
-        if not self._ptr:
-            raise ValueError('operation on destroyed loop')
+        _check_loop(self)
         libev.ev_unref(self._ptr)
 
     def break_(self, int how=libev.EVBREAK_ONE):
-        
-        if not self._ptr:
-            raise ValueError('operation on destroyed loop')
+        _check_loop(self)
         libev.ev_break(self._ptr, how)
 
     def verify(self):
-        
-        if not self._ptr:
-            raise ValueError('operation on destroyed loop')
+        _check_loop(self)
         libev.ev_verify(self._ptr)
 
-    def now(self):
-        
-        if not self._ptr:
-            raise ValueError('operation on destroyed loop')
+    cpdef libev.ev_tstamp now(self) except *:
+        _check_loop(self)
         return libev.ev_now(self._ptr)
 
-    def update(self):
-        
-        if not self._ptr:
-            raise ValueError('operation on destroyed loop')
+    cpdef void update_now(self) except *:
+        _check_loop(self)
         libev.ev_now_update(self._ptr)
 
+    update = update_now # Old name, deprecated.
+
     def __repr__(self):
         return '<%s at 0x%x %s>' % (self.__class__.__name__, id(self), self._format())
 
-    property default:
-
-        def __get__(self):
-            
-            if not self._ptr:
-                raise ValueError('operation on destroyed loop')
-            return True if libev.ev_is_default_loop(self._ptr) else False
-
-    property iteration:
-
-        def __get__(self):
-            
-            if not self._ptr:
-                raise ValueError('operation on destroyed loop')
-            return libev.ev_iteration(self._ptr)
-
-    property depth:
-
-        def __get__(self):
-            
-            if not self._ptr:
-                raise ValueError('operation on destroyed loop')
-            return libev.ev_depth(self._ptr)
-
-    property backend_int:
-
-        def __get__(self):
-            
-            if not self._ptr:
-                raise ValueError('operation on destroyed loop')
-            return libev.ev_backend(self._ptr)
-
-    property backend:
+    @property
+    def default(self):
+        # If we're destroyed, we are not the default loop anymore,
+        # as far as Python is concerned.
+        return self._default if self._ptr else False
+
+    @property
+    def iteration(self):
+        _check_loop(self)
+        return libev.ev_iteration(self._ptr)
+
+    @property
+    def depth(self):
+        _check_loop(self)
+        return libev.ev_depth(self._ptr)
+
+    @property
+    def backend_int(self):
+        _check_loop(self)
+        return libev.ev_backend(self._ptr)
+
+    @property
+    def backend(self):
+        _check_loop(self)
+        cdef unsigned int backend = libev.ev_backend(self._ptr)
+        for key, value in _flags:
+            if key == backend:
+                return value
+        return backend
+
+    @property
+    def pendingcnt(self):
+        _check_loop(self)
+        return libev.ev_pending_count(self._ptr)
 
-        def __get__(self):
-            
-            if not self._ptr:
-                raise ValueError('operation on destroyed loop')
-            cdef unsigned int backend = libev.ev_backend(self._ptr)
-            for key, value in _flags:
-                if key == backend:
-                    return value
-            return backend
-
-    property pendingcnt:
-
-        def __get__(self):
-            
-            if not self._ptr:
-                raise ValueError('operation on destroyed loop')
-            return libev.ev_pending_count(self._ptr)
-
-#ifdef _WIN32
     def io(self, libev.vfd_socket_t fd, int events, ref=True, priority=None):
         return io(self, fd, events, ref, priority)
-#else
-    def io(self, int fd, int events, ref=True, priority=None):
-        return io(self, fd, events, ref, priority)
-#endif
 
     def timer(self, double after, double repeat=0.0, ref=True, priority=None):
         return timer(self, after, repeat, ref, priority)
@@ -508,13 +654,15 @@ cdef public class loop [object PyGeventLoopObject, type PyGeventLoop_Type]:
     def fork(self, ref=True, priority=None):
         return fork(self, ref, priority)
 
-    def async(self, ref=True, priority=None):
-        return async(self, ref, priority)
+    def async_(self, ref=True, priority=None):
+        return async_(self, ref, priority)
 
-#ifdef _WIN32
-#else
+    # cython doesn't enforce async as a keyword
+    async = async_
 
     def child(self, int pid, bint trace=0, ref=True):
+        if sys.platform == 'win32':
+            raise AttributeError("Child watchers are not supported on Windows")
         return child(self, pid, trace, ref)
 
     def install_sigchld(self):
@@ -523,15 +671,11 @@ cdef public class loop [object PyGeventLoopObject, type PyGeventLoop_Type]:
     def reset_sigchld(self):
         libev.gevent_reset_sigchld_handler()
 
-#endif
-
     def stat(self, str path, float interval=0.0, ref=True, priority=None):
         return stat(self, path, interval, ref, priority)
 
     def run_callback(self, func, *args):
-        
-        if not self._ptr:
-            raise ValueError('operation on destroyed loop')
+        _check_loop(self)
         cdef callback cb = callback(func, args)
         self._callbacks.append(cb)
         libev.ev_ref(self._ptr)
@@ -541,20 +685,15 @@ cdef public class loop [object PyGeventLoopObject, type PyGeventLoop_Type]:
         if not self._ptr:
             return 'destroyed'
         cdef object msg = self.backend
-        if self.default:
+        if self._default:
             msg += ' default'
         msg += ' pending=%s' % self.pendingcnt
-#ifdef LIBEV_EMBED
         msg += self._format_details()
-#endif
         return msg
 
-#ifdef LIBEV_EMBED
-
     def _format_details(self):
         cdef str msg = ''
         cdef object fileno = self.fileno()
-        cdef object sigfd = None
         cdef object activecnt = None
         try:
             sigfd = self.sigfd
@@ -568,135 +707,241 @@ cdef public class loop [object PyGeventLoopObject, type PyGeventLoop_Type]:
             msg += ' ref=' + repr(activecnt)
         if fileno is not None:
             msg += ' fileno=' + repr(fileno)
-        if sigfd is not None and sigfd != -1:
-            msg += ' sigfd=' + repr(sigfd)
         return msg
 
     def fileno(self):
         cdef int fd
         if self._ptr:
-            fd = self._ptr.backend_fd
+            fd = libev.gevent_ev_loop_backend_fd(self._ptr)
             if fd >= 0:
                 return fd
 
-    property activecnt:
-
-        def __get__(self):
-            
-            if not self._ptr:
-                raise ValueError('operation on destroyed loop')
-            return self._ptr.activecnt
+    @property
+    def activecnt(self):
+        _check_loop(self)
+        return libev.gevent_ev_loop_activecnt(self._ptr)
 
-    property sig_pending:
+    @property
+    def sig_pending(self):
+        _check_loop(self)
+        return libev.gevent_ev_loop_sig_pending(self._ptr)
 
-        def __get__(self):
-            
-            if not self._ptr:
-                raise ValueError('operation on destroyed loop')
-            return self._ptr.sig_pending
-
-#if EV_USE_SIGNALFD
-    property sigfd:
-
-        def __get__(self):
-            
-            if not self._ptr:
-                raise ValueError('operation on destroyed loop')
-            return self._ptr.sigfd
-#endif
-
-    property origflags:
-
-        def __get__(self):
-            
-            if not self._ptr:
-                raise ValueError('operation on destroyed loop')
-            return _flags_to_list(self._ptr.origflags)
-
-    property origflags_int:
-
-        def __get__(self):
-            
-            if not self._ptr:
-                raise ValueError('operation on destroyed loop')
-            return self._ptr.origflags
-
-#endif
-
-
-cdef public class callback [object PyGeventCallbackObject, type PyGeventCallback_Type]:
-    cdef public object callback
-    cdef public tuple args
-
-    def __init__(self, callback, args):
-        self.callback = callback
-        self.args = args
-
-    def stop(self):
-        self.callback = None
-        self.args = None
-
-    # Note, that __nonzero__ and pending are different
-    # nonzero is used in contexts where we need to know whether to schedule another callback,
-    # so it's true if it's pending or currently running
-    # 'pending' has the same meaning as libev watchers: it is cleared before entering callback
-
-    def __nonzero__(self):
-        # it's nonzero if it's pending or currently executing
-        return self.args is not None
-
-    property pending:
-
-        def __get__(self):
-            return self.callback is not None
-
-    def __repr__(self):
-        if Py_ReprEnter(<PyObjectPtr>self) != 0:
-            return "<...>"
-        try:
-            format = self._format()
-            result = "<%s at 0x%x%s" % (self.__class__.__name__, id(self), format)
-            if self.pending:
-                result += " pending"
-            if self.callback is not None:
-                result += " callback=%r" % (self.callback, )
-            if self.args is not None:
-                result += " args=%r" % (self.args, )
-            if self.callback is None and self.args is None:
-                result += " stopped"
-            return result + ">"
-        finally:
-            Py_ReprLeave(<PyObjectPtr>self)
+    @property
+    def origflags(self):
+        return _flags_to_list(self.origflags_int)
 
-    def _format(self):
-        return ''
+    @property
+    def origflags_int(self):
+        _check_loop(self)
+        return libev.gevent_ev_loop_origflags(self._ptr)
 
+    @property
+    def sigfd(self):
+        _check_loop(self)
+        fd = libev.gevent_ev_loop_sigfd(self._ptr)
+        if fd >= 0:
+            return fd
 
+        # Explicitly not EV_USE_SIGNALFD
+        raise AttributeError("sigfd")
 
 
 # about readonly _flags attribute:
-# bit #1 set if object owns Python reference to itself (Py_INCREF was called and we must call Py_DECREF later)
+# bit #1 set if object owns Python reference to itself (Py_INCREF was
+# called and we must call Py_DECREF later)
+DEF FLAG_WATCHER_OWNS_PYREF = 1 << 0 # 0x1
 # bit #2 set if ev_unref() was called and we must call ev_ref() later
+DEF FLAG_WATCHER_NEEDS_EVREF = 1 << 1 # 0x2
 # bit #3 set if user wants to call ev_unref() before start()
+DEF FLAG_WATCHER_UNREF_BEFORE_START = 1 << 2 # 0x4
+# bits 2 and 3 are *both* set when we are active, but the user
+# request us not to be ref'd anymore. We unref us (because going active will
+# ref us) and then make a note of this in the future
+DEF FLAG_WATCHER_MASK_UNREF_NEEDS_REF = 0x6
 
 
+cdef void _python_incref(watcher self):
+    if not self._flags & FLAG_WATCHER_OWNS_PYREF:
+        Py_INCREF(self)
+        self._flags |= FLAG_WATCHER_OWNS_PYREF
 
+cdef void _python_decref(watcher self):
+    if self._flags & FLAG_WATCHER_OWNS_PYREF:
+        Py_DECREF(self)
+        self._flags &= ~FLAG_WATCHER_OWNS_PYREF
 
+cdef void _libev_ref(watcher self):
+    if self._flags & FLAG_WATCHER_NEEDS_EVREF:
+        libev.ev_ref(self.loop._ptr)
+        self._flags &= ~FLAG_WATCHER_NEEDS_EVREF
 
+cdef void _libev_unref(watcher self):
+    if self._flags & FLAG_WATCHER_MASK_UNREF_NEEDS_REF == FLAG_WATCHER_UNREF_BEFORE_START:
+        libev.ev_unref(self.loop._ptr)
+        self._flags |= FLAG_WATCHER_NEEDS_EVREF
 
 
+ctypedef void (*start_stop_func)(libev.ev_loop*, void*) nogil
 
+cdef struct start_and_stop:
+    start_stop_func start
+    start_stop_func stop
 
+cdef start_and_stop make_ss(void* start, void* stop):
+    cdef start_and_stop result = start_and_stop(<start_stop_func>start, <start_stop_func>stop)
+    return result
 
+cdef bint _watcher_start(watcher self, object callback, tuple args) except -1:
+    # This method should be called by subclasses of watcher, if they
+    # override the python-level `start` function: they've already paid
+    # for argument unpacking, and `start` cannot be cpdef since it
+    # uses varargs.
+
+    # We keep this as a function, not a cdef method of watcher.
+    # If it's a cdef method, it could potentially be overridden
+    # by a subclass, which means that the watcher gains a pointer to a
+    # function table (vtable), making each object 8 bytes larger.
+
+    _check_loop(self.loop)
+    if callback is None or not callable(callback):
+        raise TypeError("Expected callable, not %r" % (callback, ))
+    self._callback = callback
+    self.args = args
+    _libev_unref(self)
+    _python_incref(self)
+    self.__ss.start(self.loop._ptr, self.__watcher)
+    return 1
 
+cdef public class watcher [object PyGeventWatcherObject, type PyGeventWatcher_Type]:
+    """Abstract base class for all the watchers"""
+    ## pointer members
+    cdef public loop loop
+    cdef object _callback
+    cdef public tuple args
 
+    # By keeping a __watcher cached, the size of the io and timer
+    # structs becomes 152 bytes and child is 160 and stat is 512 (when
+    # the start_and_stop is inlined). On 64-bit macOS CPython 2.7. I
+    # hoped that using libev's data pointer and allocating the
+    # watchers directly and not as inline members would result in
+    # overall savings thanks to better padding, but it didn't. And it
+    # added lots of casts, making the code ugly.
+
+    # Table:
+    # gevent ver   | 1.2 | This | +data
+    # Watcher Kind |     |      |
+    # Timer        | 120 | 152  | 160
+    # IO           | 120 | 152  | 160
+    # Child        | 128 | 160  | 168
+    # Stat         | 480 | 512  | 512
+    cdef libev.ev_watcher* __watcher
+
+    # By inlining the start_and_stop struct, instead of taking the address
+    # of a static struct or using the watcher's data pointer, we
+    # use an additional pointer of memory and incur an additional pointer copy
+    # on creation.
+    # But we use fewer pointer accesses for start/stop, and they have
+    # better cache locality. (Then again, we're bigger).
+    # Right now we're going for size, so we use the pointer. IO/Timer objects
+    # are then 144 bytes.
+    cdef start_and_stop* __ss
+
+    ## Int members
+
+    # Our subclasses will declare the ev_X struct
+    # as an inline member. This is good for locality, but
+    # probably bad for alignment, as it will get tacked on
+    # immediately after our data.
+
+    # But all ev_watchers start with some ints, so maybe we can help that
+    # out by putting our ints here.
+    cdef readonly unsigned int _flags
+
+    def __init__(self, loop loop, ref=True, priority=None):
+        if not self.__watcher or not self.__ss.start or not self.__ss.stop:
+            raise ValueError("Cannot construct a bare watcher")
+        self.loop = loop
+        self._flags = 0 if ref else FLAG_WATCHER_UNREF_BEFORE_START
+        if priority is not None:
+            libev.ev_set_priority(self.__watcher, priority)
 
+    @property
+    def ref(self):
+        return False if self._flags & 4 else True
+
+    @ref.setter
+    def ref(self, object value):
+        _check_loop(self.loop)
+        if value:
+            # self.ref should be true after this.
+            if self.ref:
+               return  # ref is already True
+
+            if self._flags & FLAG_WATCHER_NEEDS_EVREF:  # ev_unref was called, undo
+               libev.ev_ref(self.loop._ptr)
+			# do not want unref, no outstanding unref
+            self._flags &= ~FLAG_WATCHER_MASK_UNREF_NEEDS_REF
+        else:
+			# self.ref must be false after this
+            if not self.ref:
+               return  # ref is already False
+            self._flags |= FLAG_WATCHER_UNREF_BEFORE_START
+            if not self._flags & FLAG_WATCHER_NEEDS_EVREF and libev.ev_is_active(self.__watcher):
+               libev.ev_unref(self.loop._ptr)
+               self._flags |= FLAG_WATCHER_NEEDS_EVREF
+
+    @property
+    def callback(self):
+        return self._callback
+
+    @callback.setter
+    def callback(self, object callback):
+        if callback is not None and not callable(callback):
+           raise TypeError("Expected callable, not %r" % (callback, ))
+        self._callback = callback
+
+    @property
+    def priority(self):
+        return libev.ev_priority(self.__watcher)
+
+    @priority.setter
+    def priority(self, int priority):
+        cdef libev.ev_watcher* w = self.__watcher
+        if libev.ev_is_active(w):
+           raise AttributeError("Cannot set priority of an active watcher")
+        libev.ev_set_priority(w, priority)
+
+    @property
+    def active(self):
+        return True if libev.ev_is_active(self.__watcher) else False
+
+    @property
+    def pending(self):
+        return True if libev.ev_is_pending(self.__watcher) else False
 
-cdef public class watcher [object PyGeventWatcherObject, type PyGeventWatcher_Type]:
-    """Abstract base class for all the watchers"""
+    def start(self, object callback, *args):
+        _watcher_start(self, callback, args)
+
+    def stop(self):
+        _check_loop(self.loop)
+        _libev_ref(self)
+        # The callback cannot possibly fire while we are executing,
+        # so this is safe.
+        self._callback = None
+        self.args = None
+        self.__ss.stop(self.loop._ptr, self.__watcher)
+        _python_decref(self)
+
+    def feed(self, int revents, object callback, *args):
+        _check_loop(self.loop)
+        self.callback = callback
+        self.args = args
+        _libev_unref(self)
+        libev.ev_feed_event(self.loop._ptr, self.__watcher, revents)
+        _python_incref(self)
 
     def __repr__(self):
-        if Py_ReprEnter(<PyObjectPtr>self) != 0:
+        if Py_ReprEnter(self) != 0:
             return "<...>"
         try:
             format = self._format()
@@ -711,450 +956,125 @@ cdef public class watcher [object PyGeventWatcherObject, type PyGeventWatcher_Ty
                 result += " args=%r" % (self.args, )
             return result + ">"
         finally:
-            Py_ReprLeave(<PyObjectPtr>self)
+            Py_ReprLeave(self)
 
     def _format(self):
         return ''
 
+    def close(self):
+        self.stop()
 
-cdef public class io(watcher) [object PyGeventIOObject, type PyGeventIO_Type]:
-
-    
-    cdef public loop loop
-    cdef object _callback
-    cdef public tuple args
-    cdef readonly int _flags
-    cdef libev.ev_io _watcher
-
-    property ref:
-
-        def __get__(self):
-            return False if self._flags & 4 else True
-
-        def __set__(self, object value):
-            
-            if not self.loop._ptr:
-                raise ValueError('operation on destroyed loop')
-            if value:
-                if not self._flags & 4:
-                    return  # ref is already True
-                if self._flags & 2:  # ev_unref was called, undo
-                    libev.ev_ref(self.loop._ptr)
-                self._flags &= ~6  # do not want unref, no outstanding unref
-            else:
-                if self._flags & 4:
-                    return  # ref is already False
-                self._flags |= 4
-                if not self._flags & 2 and libev.ev_is_active(&self._watcher):
-                    libev.ev_unref(self.loop._ptr)
-                    self._flags |= 2
-
-    property callback:
-
-        def __get__(self):
-            return self._callback
-
-        def __set__(self, object callback):
-            if not PyCallable_Check(<PyObjectPtr>callback) and callback is not None:
-                raise TypeError("Expected callable, not %r" % (callback, ))
-            self._callback = callback
-
-    def stop(self):
-        
-        if not self.loop._ptr:
-            raise ValueError('operation on destroyed loop')
-        if self._flags & 2:
-            libev.ev_ref(self.loop._ptr)
-            self._flags &= ~2
-        libev.ev_io_stop(self.loop._ptr, &self._watcher)
-        self._callback = None
-        self.args = None
-        if self._flags & 1:
-            Py_DECREF(<PyObjectPtr>self)
-            self._flags &= ~1
+    def __enter__(self):
+        return self
 
-    property priority:
+    def __exit__(self, t, v, tb):
+        self.close()
+        return
 
-        def __get__(self):
-            return libev.ev_priority(&self._watcher)
+cdef start_and_stop io_ss = make_ss(<void*>libev.ev_io_start, <void*>libev.ev_io_stop)
 
-        def __set__(self, int priority):
-            if libev.ev_is_active(&self._watcher):
-                raise AttributeError("Cannot set priority of an active watcher")
-            libev.ev_set_priority(&self._watcher, priority)
+cdef public class io(watcher) [object PyGeventIOObject, type PyGeventIO_Type]:
 
-    def feed(self, int revents, object callback, *args):
-        
-        if not self.loop._ptr:
-            raise ValueError('operation on destroyed loop')
-        self.callback = callback
-        self.args = args
-        if self._flags & 6 == 4:
-            libev.ev_unref(self.loop._ptr)
-            self._flags |= 2
-        libev.ev_feed_event(self.loop._ptr, &self._watcher, revents)
-        if not self._flags & 1:
-            Py_INCREF(<PyObjectPtr>self)
-            self._flags |= 1
+    cdef libev.ev_io _watcher
 
     def start(self, object callback, *args, pass_events=False):
-        
-        if not self.loop._ptr:
-            raise ValueError('operation on destroyed loop')
-        if callback is None:
-            raise TypeError('callback must be callable, not None')
-        self.callback = callback
         if pass_events:
-            self.args = (GEVENT_CORE_EVENTS, ) + args
-        else:
-            self.args = args
-        if self._flags & 6 == 4:
-            libev.ev_unref(self.loop._ptr)
-            self._flags |= 2
-        libev.ev_io_start(self.loop._ptr, &self._watcher)
-        if not self._flags & 1:
-            Py_INCREF(<PyObjectPtr>self)
-            self._flags |= 1
-
-    property active:
-
-        def __get__(self):
-            return True if libev.ev_is_active(&self._watcher) else False
-
-    
-    property pending:
-
-        def __get__(self):
-            return True if libev.ev_is_pending(&self._watcher) else False
-
-#ifdef _WIN32
+            args = (GEVENT_CORE_EVENTS, ) + args
+        _watcher_start(self, callback, args)
 
     def __init__(self, loop loop, libev.vfd_socket_t fd, int events, ref=True, priority=None):
-        if events & ~(libev.EV__IOFDSET | libev.EV_READ | libev.EV_WRITE):
-            raise ValueError('illegal event mask: %r' % events)
-        cdef int vfd = libev.vfd_open(fd)
-        libev.vfd_free(self._watcher.fd)
-        libev.ev_io_init(&self._watcher, <void *>gevent_callback_io, vfd, events)
-        self.loop = loop
-        if ref:
-            self._flags = 0
-        else:
-            self._flags = 4
-        if priority is not None:
-            libev.ev_set_priority(&self._watcher, priority)
-
-#else
+        watcher.__init__(self, loop, ref, priority)
 
-    def __init__(self, loop loop, int fd, int events, ref=True, priority=None):
+    def __cinit__(self, loop loop, libev.vfd_socket_t fd, int events, ref=True, priority=None):
         if fd < 0:
             raise ValueError('fd must be non-negative: %r' % fd)
         if events & ~(libev.EV__IOFDSET | libev.EV_READ | libev.EV_WRITE):
             raise ValueError('illegal event mask: %r' % events)
-        libev.ev_io_init(&self._watcher, <void *>gevent_callback_io, fd, events)
-        self.loop = loop
-        if ref:
-            self._flags = 0
-        else:
-            self._flags = 4
-        if priority is not None:
-            libev.ev_set_priority(&self._watcher, priority)
-
-#endif
-
-    property fd:
-
-        def __get__(self):
-            return libev.vfd_get(self._watcher.fd)
+        # All the vfd_functions are no-ops on POSIX
+        cdef int vfd = libev.vfd_open(fd)
+        libev.ev_io_init(&self._watcher, <void *>gevent_callback_io, vfd, events)
+        self.__watcher = <libev.ev_watcher*>&self._watcher
+        self.__ss = &io_ss
 
-        def __set__(self, long fd):
-            if libev.ev_is_active(&self._watcher):
-                raise AttributeError("'io' watcher attribute 'fd' is read-only while watcher is active")
-            cdef int vfd = libev.vfd_open(fd)
-            libev.vfd_free(self._watcher.fd)
-            libev.ev_io_init(&self._watcher, <void *>gevent_callback_io, vfd, self._watcher.events)
+    def __dealloc__(self):
+        libev.vfd_free(self._watcher.fd)
 
-    property events:
+    @property
+    def fd(self):
+        return libev.vfd_get(self._watcher.fd)
 
-        def __get__(self):
-            return self._watcher.events
+    @fd.setter
+    def fd(self, long fd):
+        if libev.ev_is_active(&self._watcher):
+            raise AttributeError("'io' watcher attribute 'fd' is read-only while watcher is active")
+        cdef int vfd = libev.vfd_open(fd)
+        libev.vfd_free(self._watcher.fd)
+        libev.ev_io_init(&self._watcher, <void *>gevent_callback_io, vfd, self._watcher.events)
 
-        def __set__(self, int events):
-            if libev.ev_is_active(&self._watcher):
-                raise AttributeError("'io' watcher attribute 'events' is read-only while watcher is active")
-            libev.ev_io_init(&self._watcher, <void *>gevent_callback_io, self._watcher.fd, events)
+    @property
+    def events(self):
+        return self._watcher.events
 
-    property events_str:
+    @events.setter
+    def events(self, int events):
+        if libev.ev_is_active(&self._watcher):
+            raise AttributeError("'io' watcher attribute 'events' is read-only while watcher is active")
+        libev.ev_io_init(&self._watcher, <void *>gevent_callback_io, self._watcher.fd, events)
 
-        def __get__(self):
-            return _events_to_str(self._watcher.events)
+    @property
+    def events_str(self):
+        return _events_to_str(self._watcher.events)
 
     def _format(self):
         return ' fd=%s events=%s' % (self.fd, self.events_str)
 
-#ifdef _WIN32
-
-    def __cinit__(self):
-        self._watcher.fd = -1;
-
-    def __dealloc__(self):
-        libev.vfd_free(self._watcher.fd)
-
-#endif
-
+cdef start_and_stop timer_ss = make_ss(<void*>libev.ev_timer_start, <void*>libev.ev_timer_stop)
 
 cdef public class timer(watcher) [object PyGeventTimerObject, type PyGeventTimer_Type]:
 
-    
-    cdef public loop loop
-    cdef object _callback
-    cdef public tuple args
-    cdef readonly int _flags
     cdef libev.ev_timer _watcher
 
-    property ref:
-
-        def __get__(self):
-            return False if self._flags & 4 else True
-
-        def __set__(self, object value):
-            
-            if not self.loop._ptr:
-                raise ValueError('operation on destroyed loop')
-            if value:
-                if not self._flags & 4:
-                    return  # ref is already True
-                if self._flags & 2:  # ev_unref was called, undo
-                    libev.ev_ref(self.loop._ptr)
-                self._flags &= ~6  # do not want unref, no outstanding unref
-            else:
-                if self._flags & 4:
-                    return  # ref is already False
-                self._flags |= 4
-                if not self._flags & 2 and libev.ev_is_active(&self._watcher):
-                    libev.ev_unref(self.loop._ptr)
-                    self._flags |= 2
-
-    property callback:
-
-        def __get__(self):
-            return self._callback
-
-        def __set__(self, object callback):
-            if not PyCallable_Check(<PyObjectPtr>callback) and callback is not None:
-                raise TypeError("Expected callable, not %r" % (callback, ))
-            self._callback = callback
-
-    def stop(self):
-        
-        if not self.loop._ptr:
-            raise ValueError('operation on destroyed loop')
-        if self._flags & 2:
-            libev.ev_ref(self.loop._ptr)
-            self._flags &= ~2
-        libev.ev_timer_stop(self.loop._ptr, &self._watcher)
-        self._callback = None
-        self.args = None
-        if self._flags & 1:
-            Py_DECREF(<PyObjectPtr>self)
-            self._flags &= ~1
-
-    property priority:
-
-        def __get__(self):
-            return libev.ev_priority(&self._watcher)
-
-        def __set__(self, int priority):
-            if libev.ev_is_active(&self._watcher):
-                raise AttributeError("Cannot set priority of an active watcher")
-            libev.ev_set_priority(&self._watcher, priority)
-
-    def feed(self, int revents, object callback, *args):
-        
-        if not self.loop._ptr:
-            raise ValueError('operation on destroyed loop')
-        self.callback = callback
-        self.args = args
-        if self._flags & 6 == 4:
-            libev.ev_unref(self.loop._ptr)
-            self._flags |= 2
-        libev.ev_feed_event(self.loop._ptr, &self._watcher, revents)
-        if not self._flags & 1:
-            Py_INCREF(<PyObjectPtr>self)
-            self._flags |= 1
-
-    def start(self, object callback, *args, update=True):
-        
-        if not self.loop._ptr:
-            raise ValueError('operation on destroyed loop')
-        if callback is None:
-            raise TypeError('callback must be callable, not None')
-        self.callback = callback
-        self.args = args
-        if self._flags & 6 == 4:
-            libev.ev_unref(self.loop._ptr)
-            self._flags |= 2
-        if update:
-            libev.ev_now_update(self.loop._ptr)
-        libev.ev_timer_start(self.loop._ptr, &self._watcher)
-        if not self._flags & 1:
-            Py_INCREF(<PyObjectPtr>self)
-            self._flags |= 1
-
-    property active:
-
-        def __get__(self):
-            return True if libev.ev_is_active(&self._watcher) else False
-
-    
-    property pending:
-
-        def __get__(self):
-            return True if libev.ev_is_pending(&self._watcher) else False
-
-    def __init__(self, loop loop, double after=0.0, double repeat=0.0, ref=True, priority=None):
+    def __cinit__(self, loop loop, double after=0.0, double repeat=0.0, ref=True, priority=None):
         if repeat < 0.0:
             raise ValueError("repeat must be positive or zero: %r" % repeat)
         libev.ev_timer_init(&self._watcher, <void *>gevent_callback_timer, after, repeat)
-        self.loop = loop
-        if ref:
-            self._flags = 0
-        else:
-            self._flags = 4
-        if priority is not None:
-            libev.ev_set_priority(&self._watcher, priority)
+        self.__watcher = <libev.ev_watcher*>&self._watcher
+        self.__ss = &timer_ss
 
-    property at:
+    def __init__(self, loop loop, double after=0.0, double repeat=0.0, ref=True, priority=None):
+        watcher.__init__(self, loop, ref, priority)
 
-        def __get__(self):
-            return self._watcher.at
+    def start(self, object callback, *args, update=None):
+        update = update if update is not None else self.loop.starting_timer_may_update_loop_time
+        if update:
+            self.loop.update_now()
+        _watcher_start(self, callback, args)
+
+    @property
+    def at(self):
+        return self._watcher.at
 
     # QQQ: add 'after' and 'repeat' properties?
 
     def again(self, object callback, *args, update=True):
-        
-        if not self.loop._ptr:
-            raise ValueError('operation on destroyed loop')
+        _check_loop(self.loop)
         self.callback = callback
         self.args = args
-        if self._flags & 6 == 4:
-            libev.ev_unref(self.loop._ptr)
-            self._flags |= 2
+        _libev_unref(self)
         if update:
             libev.ev_now_update(self.loop._ptr)
         libev.ev_timer_again(self.loop._ptr, &self._watcher)
-        if not self._flags & 1:
-            Py_INCREF(<PyObjectPtr>self)
-            self._flags |= 1
-
-
-cdef public class signal(watcher) [object PyGeventSignalObject, type PyGeventSignal_Type]:
-
-    
-    cdef public loop loop
-    cdef object _callback
-    cdef public tuple args
-    cdef readonly int _flags
-    cdef libev.ev_signal _watcher
-
-    property ref:
-
-        def __get__(self):
-            return False if self._flags & 4 else True
-
-        def __set__(self, object value):
-            
-            if not self.loop._ptr:
-                raise ValueError('operation on destroyed loop')
-            if value:
-                if not self._flags & 4:
-                    return  # ref is already True
-                if self._flags & 2:  # ev_unref was called, undo
-                    libev.ev_ref(self.loop._ptr)
-                self._flags &= ~6  # do not want unref, no outstanding unref
-            else:
-                if self._flags & 4:
-                    return  # ref is already False
-                self._flags |= 4
-                if not self._flags & 2 and libev.ev_is_active(&self._watcher):
-                    libev.ev_unref(self.loop._ptr)
-                    self._flags |= 2
-
-    property callback:
-
-        def __get__(self):
-            return self._callback
+        _python_incref(self)
 
-        def __set__(self, object callback):
-            if not PyCallable_Check(<PyObjectPtr>callback) and callback is not None:
-                raise TypeError("Expected callable, not %r" % (callback, ))
-            self._callback = callback
 
-    def stop(self):
-        
-        if not self.loop._ptr:
-            raise ValueError('operation on destroyed loop')
-        if self._flags & 2:
-            libev.ev_ref(self.loop._ptr)
-            self._flags &= ~2
-        libev.ev_signal_stop(self.loop._ptr, &self._watcher)
-        self._callback = None
-        self.args = None
-        if self._flags & 1:
-            Py_DECREF(<PyObjectPtr>self)
-            self._flags &= ~1
-
-    property priority:
-
-        def __get__(self):
-            return libev.ev_priority(&self._watcher)
 
-        def __set__(self, int priority):
-            if libev.ev_is_active(&self._watcher):
-                raise AttributeError("Cannot set priority of an active watcher")
-            libev.ev_set_priority(&self._watcher, priority)
-
-    def feed(self, int revents, object callback, *args):
-        
-        if not self.loop._ptr:
-            raise ValueError('operation on destroyed loop')
-        self.callback = callback
-        self.args = args
-        if self._flags & 6 == 4:
-            libev.ev_unref(self.loop._ptr)
-            self._flags |= 2
-        libev.ev_feed_event(self.loop._ptr, &self._watcher, revents)
-        if not self._flags & 1:
-            Py_INCREF(<PyObjectPtr>self)
-            self._flags |= 1
+cdef start_and_stop signal_ss = make_ss(<void*>libev.ev_signal_start, <void*>libev.ev_signal_stop)
 
-    def start(self, object callback, *args):
-        
-        if not self.loop._ptr:
-            raise ValueError('operation on destroyed loop')
-        if callback is None:
-            raise TypeError('callback must be callable, not None')
-        self.callback = callback
-        self.args = args
-        if self._flags & 6 == 4:
-            libev.ev_unref(self.loop._ptr)
-            self._flags |= 2
-        libev.ev_signal_start(self.loop._ptr, &self._watcher)
-        if not self._flags & 1:
-            Py_INCREF(<PyObjectPtr>self)
-            self._flags |= 1
-
-    property active:
-
-        def __get__(self):
-            return True if libev.ev_is_active(&self._watcher) else False
-
-    
-    property pending:
+cdef public class signal(watcher) [object PyGeventSignalObject, type PyGeventSignal_Type]:
 
-        def __get__(self):
-            return True if libev.ev_is_pending(&self._watcher) else False
+    cdef libev.ev_signal _watcher
 
-    def __init__(self, loop loop, int signalnum, ref=True, priority=None):
+    def __cinit__(self, loop loop, int signalnum, ref=True, priority=None):
         if signalnum < 1 or signalnum >= signalmodule.NSIG:
             raise ValueError('illegal signal number: %r' % signalnum)
         # still possible to crash on one of libev's asserts:
@@ -1163,872 +1083,140 @@ cdef public class signal(watcher) [object PyGeventSignalObject, type PyGeventSig
         # 2) "libev: a signal must not be attached to two different loops"
         #    we probably could check that in LIBEV_EMBED mode, but not in general
         libev.ev_signal_init(&self._watcher, <void *>gevent_callback_signal, signalnum)
-        self.loop = loop
-        if ref:
-            self._flags = 0
-        else:
-            self._flags = 4
-        if priority is not None:
-            libev.ev_set_priority(&self._watcher, priority)
-
+        self.__watcher = <libev.ev_watcher*>&self._watcher
+        self.__ss = &signal_ss
 
-cdef public class idle(watcher) [object PyGeventIdleObject, type PyGeventIdle_Type]:
-
-    
-    cdef public loop loop
-    cdef object _callback
-    cdef public tuple args
-    cdef readonly int _flags
-    cdef libev.ev_idle _watcher
-
-    property ref:
-
-        def __get__(self):
-            return False if self._flags & 4 else True
-
-        def __set__(self, object value):
-            
-            if not self.loop._ptr:
-                raise ValueError('operation on destroyed loop')
-            if value:
-                if not self._flags & 4:
-                    return  # ref is already True
-                if self._flags & 2:  # ev_unref was called, undo
-                    libev.ev_ref(self.loop._ptr)
-                self._flags &= ~6  # do not want unref, no outstanding unref
-            else:
-                if self._flags & 4:
-                    return  # ref is already False
-                self._flags |= 4
-                if not self._flags & 2 and libev.ev_is_active(&self._watcher):
-                    libev.ev_unref(self.loop._ptr)
-                    self._flags |= 2
-
-    property callback:
-
-        def __get__(self):
-            return self._callback
-
-        def __set__(self, object callback):
-            if not PyCallable_Check(<PyObjectPtr>callback) and callback is not None:
-                raise TypeError("Expected callable, not %r" % (callback, ))
-            self._callback = callback
-
-    def stop(self):
-        
-        if not self.loop._ptr:
-            raise ValueError('operation on destroyed loop')
-        if self._flags & 2:
-            libev.ev_ref(self.loop._ptr)
-            self._flags &= ~2
-        libev.ev_idle_stop(self.loop._ptr, &self._watcher)
-        self._callback = None
-        self.args = None
-        if self._flags & 1:
-            Py_DECREF(<PyObjectPtr>self)
-            self._flags &= ~1
-
-    property priority:
-
-        def __get__(self):
-            return libev.ev_priority(&self._watcher)
+    def __init__(self, loop loop, int signalnum, ref=True, priority=None):
+        watcher.__init__(self, loop, ref, priority)
 
-        def __set__(self, int priority):
-            if libev.ev_is_active(&self._watcher):
-                raise AttributeError("Cannot set priority of an active watcher")
-            libev.ev_set_priority(&self._watcher, priority)
 
-    def feed(self, int revents, object callback, *args):
-        
-        if not self.loop._ptr:
-            raise ValueError('operation on destroyed loop')
-        self.callback = callback
-        self.args = args
-        if self._flags & 6 == 4:
-            libev.ev_unref(self.loop._ptr)
-            self._flags |= 2
-        libev.ev_feed_event(self.loop._ptr, &self._watcher, revents)
-        if not self._flags & 1:
-            Py_INCREF(<PyObjectPtr>self)
-            self._flags |= 1
 
-    def start(self, object callback, *args):
-        
-        if not self.loop._ptr:
-            raise ValueError('operation on destroyed loop')
-        if callback is None:
-            raise TypeError('callback must be callable, not None')
-        self.callback = callback
-        self.args = args
-        if self._flags & 6 == 4:
-            libev.ev_unref(self.loop._ptr)
-            self._flags |= 2
-        libev.ev_idle_start(self.loop._ptr, &self._watcher)
-        if not self._flags & 1:
-            Py_INCREF(<PyObjectPtr>self)
-            self._flags |= 1
+cdef start_and_stop idle_ss = make_ss(<void*>libev.ev_idle_start, <void*>libev.ev_idle_stop)
 
-    property active:
+cdef public class idle(watcher) [object PyGeventIdleObject, type PyGeventIdle_Type]:
 
-        def __get__(self):
-            return True if libev.ev_is_active(&self._watcher) else False
+    cdef libev.ev_idle _watcher
 
-    
-    property pending:
+    def __cinit__(self, loop loop, ref=True, priority=None):
+        libev.ev_idle_init(&self._watcher, <void*>gevent_callback_idle)
+        self.__watcher = <libev.ev_watcher*>&self._watcher
+        self.__ss = &idle_ss
 
-        def __get__(self):
-            return True if libev.ev_is_pending(&self._watcher) else False
 
-    
-    def __init__(self, loop loop , ref=True, priority=None):
-        libev.ev_idle_init(&self._watcher, <void *>gevent_callback_idle )
-        self.loop = loop
-        if ref:
-            self._flags = 0
-        else:
-            self._flags = 4
-        if priority is not None:
-            libev.ev_set_priority(&self._watcher, priority)
 
+cdef start_and_stop prepare_ss = make_ss(<void*>libev.ev_prepare_start, <void*>libev.ev_prepare_stop)
 
 cdef public class prepare(watcher) [object PyGeventPrepareObject, type PyGeventPrepare_Type]:
 
-    
-    cdef public loop loop
-    cdef object _callback
-    cdef public tuple args
-    cdef readonly int _flags
     cdef libev.ev_prepare _watcher
 
-    property ref:
-
-        def __get__(self):
-            return False if self._flags & 4 else True
+    def __cinit__(self, loop loop, ref=True, priority=None):
+        libev.ev_prepare_init(&self._watcher, <void*>gevent_callback_prepare)
+        self.__watcher = <libev.ev_watcher*>&self._watcher
+        self.__ss = &prepare_ss
 
-        def __set__(self, object value):
-            
-            if not self.loop._ptr:
-                raise ValueError('operation on destroyed loop')
-            if value:
-                if not self._flags & 4:
-                    return  # ref is already True
-                if self._flags & 2:  # ev_unref was called, undo
-                    libev.ev_ref(self.loop._ptr)
-                self._flags &= ~6  # do not want unref, no outstanding unref
-            else:
-                if self._flags & 4:
-                    return  # ref is already False
-                self._flags |= 4
-                if not self._flags & 2 and libev.ev_is_active(&self._watcher):
-                    libev.ev_unref(self.loop._ptr)
-                    self._flags |= 2
 
-    property callback:
-
-        def __get__(self):
-            return self._callback
-
-        def __set__(self, object callback):
-            if not PyCallable_Check(<PyObjectPtr>callback) and callback is not None:
-                raise TypeError("Expected callable, not %r" % (callback, ))
-            self._callback = callback
-
-    def stop(self):
-        
-        if not self.loop._ptr:
-            raise ValueError('operation on destroyed loop')
-        if self._flags & 2:
-            libev.ev_ref(self.loop._ptr)
-            self._flags &= ~2
-        libev.ev_prepare_stop(self.loop._ptr, &self._watcher)
-        self._callback = None
-        self.args = None
-        if self._flags & 1:
-            Py_DECREF(<PyObjectPtr>self)
-            self._flags &= ~1
-
-    property priority:
-
-        def __get__(self):
-            return libev.ev_priority(&self._watcher)
-
-        def __set__(self, int priority):
-            if libev.ev_is_active(&self._watcher):
-                raise AttributeError("Cannot set priority of an active watcher")
-            libev.ev_set_priority(&self._watcher, priority)
-
-    def feed(self, int revents, object callback, *args):
-        
-        if not self.loop._ptr:
-            raise ValueError('operation on destroyed loop')
-        self.callback = callback
-        self.args = args
-        if self._flags & 6 == 4:
-            libev.ev_unref(self.loop._ptr)
-            self._flags |= 2
-        libev.ev_feed_event(self.loop._ptr, &self._watcher, revents)
-        if not self._flags & 1:
-            Py_INCREF(<PyObjectPtr>self)
-            self._flags |= 1
-
-    def start(self, object callback, *args):
-        
-        if not self.loop._ptr:
-            raise ValueError('operation on destroyed loop')
-        if callback is None:
-            raise TypeError('callback must be callable, not None')
-        self.callback = callback
-        self.args = args
-        if self._flags & 6 == 4:
-            libev.ev_unref(self.loop._ptr)
-            self._flags |= 2
-        libev.ev_prepare_start(self.loop._ptr, &self._watcher)
-        if not self._flags & 1:
-            Py_INCREF(<PyObjectPtr>self)
-            self._flags |= 1
-
-    property active:
-
-        def __get__(self):
-            return True if libev.ev_is_active(&self._watcher) else False
-
-    
-    property pending:
-
-        def __get__(self):
-            return True if libev.ev_is_pending(&self._watcher) else False
-
-    
-    def __init__(self, loop loop , ref=True, priority=None):
-        libev.ev_prepare_init(&self._watcher, <void *>gevent_callback_prepare )
-        self.loop = loop
-        if ref:
-            self._flags = 0
-        else:
-            self._flags = 4
-        if priority is not None:
-            libev.ev_set_priority(&self._watcher, priority)
 
+cdef start_and_stop check_ss = make_ss(<void*>libev.ev_check_start, <void*>libev.ev_check_stop)
 
 cdef public class check(watcher) [object PyGeventCheckObject, type PyGeventCheck_Type]:
 
-    
-    cdef public loop loop
-    cdef object _callback
-    cdef public tuple args
-    cdef readonly int _flags
     cdef libev.ev_check _watcher
 
-    property ref:
-
-        def __get__(self):
-            return False if self._flags & 4 else True
-
-        def __set__(self, object value):
-            
-            if not self.loop._ptr:
-                raise ValueError('operation on destroyed loop')
-            if value:
-                if not self._flags & 4:
-                    return  # ref is already True
-                if self._flags & 2:  # ev_unref was called, undo
-                    libev.ev_ref(self.loop._ptr)
-                self._flags &= ~6  # do not want unref, no outstanding unref
-            else:
-                if self._flags & 4:
-                    return  # ref is already False
-                self._flags |= 4
-                if not self._flags & 2 and libev.ev_is_active(&self._watcher):
-                    libev.ev_unref(self.loop._ptr)
-                    self._flags |= 2
-
-    property callback:
-
-        def __get__(self):
-            return self._callback
+    def __cinit__(self, loop loop, ref=True, priority=None):
+        libev.ev_check_init(&self._watcher, <void*>gevent_callback_check)
+        self.__watcher = <libev.ev_watcher*>&self._watcher
+        self.__ss = &check_ss
 
-        def __set__(self, object callback):
-            if not PyCallable_Check(<PyObjectPtr>callback) and callback is not None:
-                raise TypeError("Expected callable, not %r" % (callback, ))
-            self._callback = callback
 
-    def stop(self):
-        
-        if not self.loop._ptr:
-            raise ValueError('operation on destroyed loop')
-        if self._flags & 2:
-            libev.ev_ref(self.loop._ptr)
-            self._flags &= ~2
-        libev.ev_check_stop(self.loop._ptr, &self._watcher)
-        self._callback = None
-        self.args = None
-        if self._flags & 1:
-            Py_DECREF(<PyObjectPtr>self)
-            self._flags &= ~1
-
-    property priority:
-
-        def __get__(self):
-            return libev.ev_priority(&self._watcher)
-
-        def __set__(self, int priority):
-            if libev.ev_is_active(&self._watcher):
-                raise AttributeError("Cannot set priority of an active watcher")
-            libev.ev_set_priority(&self._watcher, priority)
-
-    def feed(self, int revents, object callback, *args):
-        
-        if not self.loop._ptr:
-            raise ValueError('operation on destroyed loop')
-        self.callback = callback
-        self.args = args
-        if self._flags & 6 == 4:
-            libev.ev_unref(self.loop._ptr)
-            self._flags |= 2
-        libev.ev_feed_event(self.loop._ptr, &self._watcher, revents)
-        if not self._flags & 1:
-            Py_INCREF(<PyObjectPtr>self)
-            self._flags |= 1
-
-    def start(self, object callback, *args):
-        
-        if not self.loop._ptr:
-            raise ValueError('operation on destroyed loop')
-        if callback is None:
-            raise TypeError('callback must be callable, not None')
-        self.callback = callback
-        self.args = args
-        if self._flags & 6 == 4:
-            libev.ev_unref(self.loop._ptr)
-            self._flags |= 2
-        libev.ev_check_start(self.loop._ptr, &self._watcher)
-        if not self._flags & 1:
-            Py_INCREF(<PyObjectPtr>self)
-            self._flags |= 1
-
-    property active:
-
-        def __get__(self):
-            return True if libev.ev_is_active(&self._watcher) else False
-
-    
-    property pending:
-
-        def __get__(self):
-            return True if libev.ev_is_pending(&self._watcher) else False
-
-    
-    def __init__(self, loop loop , ref=True, priority=None):
-        libev.ev_check_init(&self._watcher, <void *>gevent_callback_check )
-        self.loop = loop
-        if ref:
-            self._flags = 0
-        else:
-            self._flags = 4
-        if priority is not None:
-            libev.ev_set_priority(&self._watcher, priority)
 
+cdef start_and_stop fork_ss = make_ss(<void*>libev.ev_fork_start, <void*>libev.ev_fork_stop)
 
 cdef public class fork(watcher) [object PyGeventForkObject, type PyGeventFork_Type]:
 
-    
-    cdef public loop loop
-    cdef object _callback
-    cdef public tuple args
-    cdef readonly int _flags
     cdef libev.ev_fork _watcher
 
-    property ref:
-
-        def __get__(self):
-            return False if self._flags & 4 else True
-
-        def __set__(self, object value):
-            
-            if not self.loop._ptr:
-                raise ValueError('operation on destroyed loop')
-            if value:
-                if not self._flags & 4:
-                    return  # ref is already True
-                if self._flags & 2:  # ev_unref was called, undo
-                    libev.ev_ref(self.loop._ptr)
-                self._flags &= ~6  # do not want unref, no outstanding unref
-            else:
-                if self._flags & 4:
-                    return  # ref is already False
-                self._flags |= 4
-                if not self._flags & 2 and libev.ev_is_active(&self._watcher):
-                    libev.ev_unref(self.loop._ptr)
-                    self._flags |= 2
-
-    property callback:
-
-        def __get__(self):
-            return self._callback
-
-        def __set__(self, object callback):
-            if not PyCallable_Check(<PyObjectPtr>callback) and callback is not None:
-                raise TypeError("Expected callable, not %r" % (callback, ))
-            self._callback = callback
-
-    def stop(self):
-        
-        if not self.loop._ptr:
-            raise ValueError('operation on destroyed loop')
-        if self._flags & 2:
-            libev.ev_ref(self.loop._ptr)
-            self._flags &= ~2
-        libev.ev_fork_stop(self.loop._ptr, &self._watcher)
-        self._callback = None
-        self.args = None
-        if self._flags & 1:
-            Py_DECREF(<PyObjectPtr>self)
-            self._flags &= ~1
-
-    property priority:
-
-        def __get__(self):
-            return libev.ev_priority(&self._watcher)
-
-        def __set__(self, int priority):
-            if libev.ev_is_active(&self._watcher):
-                raise AttributeError("Cannot set priority of an active watcher")
-            libev.ev_set_priority(&self._watcher, priority)
-
-    def feed(self, int revents, object callback, *args):
-        
-        if not self.loop._ptr:
-            raise ValueError('operation on destroyed loop')
-        self.callback = callback
-        self.args = args
-        if self._flags & 6 == 4:
-            libev.ev_unref(self.loop._ptr)
-            self._flags |= 2
-        libev.ev_feed_event(self.loop._ptr, &self._watcher, revents)
-        if not self._flags & 1:
-            Py_INCREF(<PyObjectPtr>self)
-            self._flags |= 1
-
-    def start(self, object callback, *args):
-        
-        if not self.loop._ptr:
-            raise ValueError('operation on destroyed loop')
-        if callback is None:
-            raise TypeError('callback must be callable, not None')
-        self.callback = callback
-        self.args = args
-        if self._flags & 6 == 4:
-            libev.ev_unref(self.loop._ptr)
-            self._flags |= 2
-        libev.ev_fork_start(self.loop._ptr, &self._watcher)
-        if not self._flags & 1:
-            Py_INCREF(<PyObjectPtr>self)
-            self._flags |= 1
-
-    property active:
+    def __cinit__(self, loop loop, ref=True, priority=None):
+        libev.ev_fork_init(&self._watcher, <void*>gevent_callback_fork)
+        self.__watcher = <libev.ev_watcher*>&self._watcher
+        self.__ss = &fork_ss
 
-        def __get__(self):
-            return True if libev.ev_is_active(&self._watcher) else False
 
-    
-    property pending:
+cdef start_and_stop async_ss = make_ss(<void*>libev.ev_async_start, <void*>libev.ev_async_stop)
 
-        def __get__(self):
-            return True if libev.ev_is_pending(&self._watcher) else False
-
-    
-    def __init__(self, loop loop , ref=True, priority=None):
-        libev.ev_fork_init(&self._watcher, <void *>gevent_callback_fork )
-        self.loop = loop
-        if ref:
-            self._flags = 0
-        else:
-            self._flags = 4
-        if priority is not None:
-            libev.ev_set_priority(&self._watcher, priority)
+cdef public class async_(watcher) [object PyGeventAsyncObject, type PyGeventAsync_Type]:
 
-
-cdef public class async(watcher) [object PyGeventAsyncObject, type PyGeventAsync_Type]:
-
-    
-    cdef public loop loop
-    cdef object _callback
-    cdef public tuple args
-    cdef readonly int _flags
     cdef libev.ev_async _watcher
 
-    property ref:
-
-        def __get__(self):
-            return False if self._flags & 4 else True
-
-        def __set__(self, object value):
-            
-            if not self.loop._ptr:
-                raise ValueError('operation on destroyed loop')
-            if value:
-                if not self._flags & 4:
-                    return  # ref is already True
-                if self._flags & 2:  # ev_unref was called, undo
-                    libev.ev_ref(self.loop._ptr)
-                self._flags &= ~6  # do not want unref, no outstanding unref
-            else:
-                if self._flags & 4:
-                    return  # ref is already False
-                self._flags |= 4
-                if not self._flags & 2 and libev.ev_is_active(&self._watcher):
-                    libev.ev_unref(self.loop._ptr)
-                    self._flags |= 2
-
-    property callback:
-
-        def __get__(self):
-            return self._callback
-
-        def __set__(self, object callback):
-            if not PyCallable_Check(<PyObjectPtr>callback) and callback is not None:
-                raise TypeError("Expected callable, not %r" % (callback, ))
-            self._callback = callback
-
-    def stop(self):
-        
-        if not self.loop._ptr:
-            raise ValueError('operation on destroyed loop')
-        if self._flags & 2:
-            libev.ev_ref(self.loop._ptr)
-            self._flags &= ~2
-        libev.ev_async_stop(self.loop._ptr, &self._watcher)
-        self._callback = None
-        self.args = None
-        if self._flags & 1:
-            Py_DECREF(<PyObjectPtr>self)
-            self._flags &= ~1
-
-    property priority:
+    @property
+    def pending(self):
+        # Note the use of ev_async_pending instead of ev_is_pending
+        return True if libev.ev_async_pending(&self._watcher) else False
 
-        def __get__(self):
-            return libev.ev_priority(&self._watcher)
+    def __cinit__(self, loop loop, ref=True, priority=None):
+        libev.ev_async_init(&self._watcher, <void*>gevent_callback_async)
+        self.__watcher = <libev.ev_watcher*>&self._watcher
+        self.__ss = &async_ss
 
-        def __set__(self, int priority):
-            if libev.ev_is_active(&self._watcher):
-                raise AttributeError("Cannot set priority of an active watcher")
-            libev.ev_set_priority(&self._watcher, priority)
-
-    def feed(self, int revents, object callback, *args):
-        
-        if not self.loop._ptr:
-            raise ValueError('operation on destroyed loop')
-        self.callback = callback
-        self.args = args
-        if self._flags & 6 == 4:
-            libev.ev_unref(self.loop._ptr)
-            self._flags |= 2
-        libev.ev_feed_event(self.loop._ptr, &self._watcher, revents)
-        if not self._flags & 1:
-            Py_INCREF(<PyObjectPtr>self)
-            self._flags |= 1
-
-    def start(self, object callback, *args):
-        
-        if not self.loop._ptr:
-            raise ValueError('operation on destroyed loop')
-        if callback is None:
-            raise TypeError('callback must be callable, not None')
-        self.callback = callback
-        self.args = args
-        if self._flags & 6 == 4:
-            libev.ev_unref(self.loop._ptr)
-            self._flags |= 2
-        libev.ev_async_start(self.loop._ptr, &self._watcher)
-        if not self._flags & 1:
-            Py_INCREF(<PyObjectPtr>self)
-            self._flags |= 1
-
-    property active:
-
-        def __get__(self):
-            return True if libev.ev_is_active(&self._watcher) else False
-
-    property pending:
-
-        def __get__(self):
-            return True if libev.ev_async_pending(&self._watcher) else False
-
-    
-    def __init__(self, loop loop , ref=True, priority=None):
-        libev.ev_async_init(&self._watcher, <void *>gevent_callback_async )
-        self.loop = loop
-        if ref:
-            self._flags = 0
-        else:
-            self._flags = 4
-        if priority is not None:
-            libev.ev_set_priority(&self._watcher, priority)
 
     def send(self):
-        
-        if not self.loop._ptr:
-            raise ValueError('operation on destroyed loop')
+        _check_loop(self.loop)
         libev.ev_async_send(self.loop._ptr, &self._watcher)
 
-#ifdef _WIN32
-#else
+async = async_
+
+cdef start_and_stop child_ss = make_ss(<void*>libev.ev_child_start, <void*>libev.ev_child_stop)
 
 cdef public class child(watcher) [object PyGeventChildObject, type PyGeventChild_Type]:
 
-    
-    cdef public loop loop
-    cdef object _callback
-    cdef public tuple args
-    cdef readonly int _flags
     cdef libev.ev_child _watcher
 
-    property ref:
-
-        def __get__(self):
-            return False if self._flags & 4 else True
-
-        def __set__(self, object value):
-            
-            if not self.loop._ptr:
-                raise ValueError('operation on destroyed loop')
-            if value:
-                if not self._flags & 4:
-                    return  # ref is already True
-                if self._flags & 2:  # ev_unref was called, undo
-                    libev.ev_ref(self.loop._ptr)
-                self._flags &= ~6  # do not want unref, no outstanding unref
-            else:
-                if self._flags & 4:
-                    return  # ref is already False
-                self._flags |= 4
-                if not self._flags & 2 and libev.ev_is_active(&self._watcher):
-                    libev.ev_unref(self.loop._ptr)
-                    self._flags |= 2
-
-    property callback:
-
-        def __get__(self):
-            return self._callback
-
-        def __set__(self, object callback):
-            if not PyCallable_Check(<PyObjectPtr>callback) and callback is not None:
-                raise TypeError("Expected callable, not %r" % (callback, ))
-            self._callback = callback
-
-    def stop(self):
-        
-        if not self.loop._ptr:
-            raise ValueError('operation on destroyed loop')
-        if self._flags & 2:
-            libev.ev_ref(self.loop._ptr)
-            self._flags &= ~2
-        libev.ev_child_stop(self.loop._ptr, &self._watcher)
-        self._callback = None
-        self.args = None
-        if self._flags & 1:
-            Py_DECREF(<PyObjectPtr>self)
-            self._flags &= ~1
-
-    property priority:
-
-        def __get__(self):
-            return libev.ev_priority(&self._watcher)
-
-        def __set__(self, int priority):
-            if libev.ev_is_active(&self._watcher):
-                raise AttributeError("Cannot set priority of an active watcher")
-            libev.ev_set_priority(&self._watcher, priority)
-
-    def feed(self, int revents, object callback, *args):
-        
-        if not self.loop._ptr:
-            raise ValueError('operation on destroyed loop')
-        self.callback = callback
-        self.args = args
-        if self._flags & 6 == 4:
-            libev.ev_unref(self.loop._ptr)
-            self._flags |= 2
-        libev.ev_feed_event(self.loop._ptr, &self._watcher, revents)
-        if not self._flags & 1:
-            Py_INCREF(<PyObjectPtr>self)
-            self._flags |= 1
-
-    def start(self, object callback, *args):
-        
-        if not self.loop._ptr:
-            raise ValueError('operation on destroyed loop')
-        if callback is None:
-            raise TypeError('callback must be callable, not None')
-        self.callback = callback
-        self.args = args
-        if self._flags & 6 == 4:
-            libev.ev_unref(self.loop._ptr)
-            self._flags |= 2
-        libev.ev_child_start(self.loop._ptr, &self._watcher)
-        if not self._flags & 1:
-            Py_INCREF(<PyObjectPtr>self)
-            self._flags |= 1
-
-    property active:
-
-        def __get__(self):
-            return True if libev.ev_is_active(&self._watcher) else False
-
-    
-    property pending:
-
-        def __get__(self):
-            return True if libev.ev_is_pending(&self._watcher) else False
-
-    def __init__(self, loop loop, int pid, bint trace=0, ref=True):
+    def __cinit__(self, loop loop, int pid, bint trace=0, ref=True):
+        if sys.platform == 'win32':
+            raise AttributeError("Child watchers are not supported on Windows")
         if not loop.default:
             raise TypeError('child watchers are only available on the default loop')
         libev.gevent_install_sigchld_handler()
         libev.ev_child_init(&self._watcher, <void *>gevent_callback_child, pid, trace)
-        self.loop = loop
-        if ref:
-            self._flags = 0
-        else:
-            self._flags = 4
-
-    def _format(self):
-        return ' pid=%r rstatus=%r' % (self.pid, self.rstatus)
-
-    property pid:
+        self.__watcher = <libev.ev_watcher*>&self._watcher
+        self.__ss = &child_ss
 
-        def __get__(self):
-            return self._watcher.pid
+    def __init__(self, loop loop, int pid, bint trace=0, ref=True):
+        watcher.__init__(self, loop, ref, None)
 
-    property rpid:
 
-        def __get__(self):
-            return self._watcher.rpid
+    def _format(self):
+        return ' pid=%r rstatus=%r' % (self.pid, self.rstatus)
 
-        def __set__(self, int value):
-            self._watcher.rpid = value
+    @property
+    def pid(self):
+        return self._watcher.pid
 
-    property rstatus:
+    @property
+    def rpid(self):
+        return self._watcher.rpid
 
-        def __get__(self):
-            return self._watcher.rstatus
+    @rpid.setter
+    def rpid(self, int value):
+        self._watcher.rpid = value
 
-        def __set__(self, int value):
-            self._watcher.rstatus = value
+    @property
+    def rstatus(self):
+        return self._watcher.rstatus
 
-#endif
+    @rstatus.setter
+    def rstatus(self, int value):
+        self._watcher.rstatus = value
 
+cdef start_and_stop stat_ss = make_ss(<void*>libev.ev_stat_start, <void*>libev.ev_stat_stop)
 
 cdef public class stat(watcher) [object PyGeventStatObject, type PyGeventStat_Type]:
 
-    
-    cdef public loop loop
-    cdef object _callback
-    cdef public tuple args
-    cdef readonly int _flags
     cdef libev.ev_stat _watcher
-
-    property ref:
-
-        def __get__(self):
-            return False if self._flags & 4 else True
-
-        def __set__(self, object value):
-            
-            if not self.loop._ptr:
-                raise ValueError('operation on destroyed loop')
-            if value:
-                if not self._flags & 4:
-                    return  # ref is already True
-                if self._flags & 2:  # ev_unref was called, undo
-                    libev.ev_ref(self.loop._ptr)
-                self._flags &= ~6  # do not want unref, no outstanding unref
-            else:
-                if self._flags & 4:
-                    return  # ref is already False
-                self._flags |= 4
-                if not self._flags & 2 and libev.ev_is_active(&self._watcher):
-                    libev.ev_unref(self.loop._ptr)
-                    self._flags |= 2
-
-    property callback:
-
-        def __get__(self):
-            return self._callback
-
-        def __set__(self, object callback):
-            if not PyCallable_Check(<PyObjectPtr>callback) and callback is not None:
-                raise TypeError("Expected callable, not %r" % (callback, ))
-            self._callback = callback
-
-    def stop(self):
-        
-        if not self.loop._ptr:
-            raise ValueError('operation on destroyed loop')
-        if self._flags & 2:
-            libev.ev_ref(self.loop._ptr)
-            self._flags &= ~2
-        libev.ev_stat_stop(self.loop._ptr, &self._watcher)
-        self._callback = None
-        self.args = None
-        if self._flags & 1:
-            Py_DECREF(<PyObjectPtr>self)
-            self._flags &= ~1
-
-    property priority:
-
-        def __get__(self):
-            return libev.ev_priority(&self._watcher)
-
-        def __set__(self, int priority):
-            if libev.ev_is_active(&self._watcher):
-                raise AttributeError("Cannot set priority of an active watcher")
-            libev.ev_set_priority(&self._watcher, priority)
-
-    def feed(self, int revents, object callback, *args):
-        
-        if not self.loop._ptr:
-            raise ValueError('operation on destroyed loop')
-        self.callback = callback
-        self.args = args
-        if self._flags & 6 == 4:
-            libev.ev_unref(self.loop._ptr)
-            self._flags |= 2
-        libev.ev_feed_event(self.loop._ptr, &self._watcher, revents)
-        if not self._flags & 1:
-            Py_INCREF(<PyObjectPtr>self)
-            self._flags |= 1
-
-    def start(self, object callback, *args):
-        
-        if not self.loop._ptr:
-            raise ValueError('operation on destroyed loop')
-        if callback is None:
-            raise TypeError('callback must be callable, not None')
-        self.callback = callback
-        self.args = args
-        if self._flags & 6 == 4:
-            libev.ev_unref(self.loop._ptr)
-            self._flags |= 2
-        libev.ev_stat_start(self.loop._ptr, &self._watcher)
-        if not self._flags & 1:
-            Py_INCREF(<PyObjectPtr>self)
-            self._flags |= 1
-
-    property active:
-
-        def __get__(self):
-            return True if libev.ev_is_active(&self._watcher) else False
-
-    
-    property pending:
-
-        def __get__(self):
-            return True if libev.ev_is_pending(&self._watcher) else False
     cdef readonly str path
     cdef readonly bytes _paths
 
-    def __init__(self, loop loop, str path, float interval=0.0, ref=True, priority=None):
+    def __cinit__(self, loop loop, str path, float interval=0.0, ref=True, priority=None):
         self.path = path
         cdef bytes paths
         if isinstance(path, unicode):
@@ -2041,32 +1229,29 @@ cdef public class stat(watcher) [object PyGeventStatObject, type PyGeventStat_Ty
             paths = <bytes>path
             self._paths = paths
         libev.ev_stat_init(&self._watcher, <void *>gevent_callback_stat, <char*>paths, interval)
-        self.loop = loop
-        if ref:
-            self._flags = 0
-        else:
-            self._flags = 4
-        if priority is not None:
-            libev.ev_set_priority(&self._watcher, priority)
+        self.__watcher = <libev.ev_watcher*>&self._watcher
+        self.__ss = &stat_ss
 
-    property attr:
+    def __init__(self, loop loop, str path, float interval=0.0, ref=True, priority=None):
+        watcher.__init__(self, loop, ref, priority)
 
-        def __get__(self):
-            if not self._watcher.attr.st_nlink:
-                return
-            return _pystat_fromstructstat(&self._watcher.attr)
 
-    property prev:
+    @property
+    def attr(self):
+        if not self._watcher.attr.st_nlink:
+            return
+        return _pystat_fromstructstat(&self._watcher.attr)
 
-       def __get__(self):
-            if not self._watcher.prev.st_nlink:
-                return
-            return _pystat_fromstructstat(&self._watcher.prev)
+    @property
+    def prev(self):
+        if not self._watcher.prev.st_nlink:
+            return
+        return _pystat_fromstructstat(&self._watcher.prev)
 
-    property interval:
+    @property
+    def interval(self):
+        return self._watcher.interval
 
-        def __get__(self):
-            return self._watcher.interval
 
 
 __SYSERR_CALLBACK = None
@@ -2094,8 +1279,8 @@ cpdef set_syserr_cb(callback):
         raise TypeError('Expected callable or None, got %r' % (callback, ))
 
 
-#ifdef LIBEV_EMBED
-LIBEV_EMBED = True
+
+LIBEV_EMBED = bool(libev.LIBEV_EMBED)
 EV_USE_FLOOR = libev.EV_USE_FLOOR
 EV_USE_CLOCK_SYSCALL = libev.EV_USE_CLOCK_SYSCALL
 EV_USE_REALTIME = libev.EV_USE_REALTIME
@@ -2105,6 +1290,51 @@ EV_USE_INOTIFY = libev.EV_USE_INOTIFY
 EV_USE_SIGNALFD = libev.EV_USE_SIGNALFD
 EV_USE_EVENTFD = libev.EV_USE_EVENTFD
 EV_USE_4HEAP = libev.EV_USE_4HEAP
-#else
-LIBEV_EMBED = False
-#endif
+
+# Things used in callbacks.c
+
+from cpython cimport PyErr_Fetch
+from cpython cimport PyObject
+
+cdef public void gevent_handle_error(loop loop, object context):
+    cdef PyObject* typep
+    cdef PyObject* valuep
+    cdef PyObject* tracebackp
+
+    cdef object type
+    cdef object value = None
+    cdef object traceback = None
+    cdef object result
+
+    # If it was set, this will clear it, and we will own
+    # the references.
+    PyErr_Fetch(&typep, &valuep, &tracebackp)
+    # TODO: Should we call PyErr_Normalize? There's code in
+    # Hub.handle_error that works around what looks like an
+    # unnormalized exception.
+
+    if not typep:
+        return
+    # This assignment will do a Py_INCREF
+    # on the value. We already own the reference
+    # returned from PyErr_Fetch,
+    # so we must decref immediately
+    type = <object>typep
+    Py_DECREF(type)
+
+    if valuep:
+        value = <object>valuep
+        Py_DECREF(value)
+    if tracebackp:
+        traceback = <object>tracebackp
+        Py_DECREF(traceback)
+
+    # If this method fails by raising an exception,
+    # cython will print it for us because we don't return a
+    # Python object and we don't declare an `except` clause.
+    loop.handle_error(context, type, value, traceback)
+
+cdef public tuple _empty_tuple = ()
+
+cdef public object gevent_loop_run_callbacks(loop loop):
+    return loop._run_callbacks()