Add Windows IOCP and Kqueue implementations for the event loop

source/tanya/async/event/epoll.d

@@ -0,0 +1,178 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Copyright: Eugene Wissner 2016.
+ * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
+ *                  Mozilla Public License, v. 2.0).
+ * Authors: $(LINK2 mailto:belka@caraus.de, Eugene Wissner)
+ */
+module tanya.async.event.epoll;
+
+version (linux):
+
+public import core.sys.linux.epoll;
+import tanya.async.protocol;
+import tanya.async.event.selector;
+import tanya.async.loop;
+import tanya.async.transport;
+import tanya.async.watcher;
+import tanya.memory;
+import tanya.memory.mmappool;
+import tanya.network.socket;
+import core.stdc.errno;
+import core.sys.posix.unistd;
+import core.time;
+import std.algorithm.comparison;
+
+class EpollLoop : SelectorLoop
+{
+    protected int fd;
+    private epoll_event[] events;
+
+    /**
+     * Initializes the loop.
+     */
+    this()
+    {
+        if ((fd = epoll_create1(EPOLL_CLOEXEC)) < 0)
+        {
+            throw MmapPool.instance.make!BadLoopException("epoll initialization failed");
+        }
+        super();
+        events = MmapPool.instance.makeArray!epoll_event(maxEvents);
+    }
+
+    /**
+     * Free loop internals.
+     */
+    ~this()
+    {
+        MmapPool.instance.dispose(events);
+        close(fd);
+    }
+
+    /**
+     * Should be called if the backend configuration changes.
+     *
+     * Params:
+     *     watcher   = Watcher.
+     *     oldEvents = The events were already set.
+     *     events    = The events should be set.
+     *
+     * Returns: $(D_KEYWORD true) if the operation was successful.
+     */
+    protected override bool reify(ConnectionWatcher watcher, EventMask oldEvents, EventMask events)
+    in
+    {
+        assert(watcher !is null);
+    }
+    body
+    {
+        int op = EPOLL_CTL_DEL;
+        epoll_event ev;
+
+        if (events == oldEvents)
+        {
+            return true;
+        }
+        if (events && oldEvents)
+        {
+            op = EPOLL_CTL_MOD;
+        }
+        else if (events && !oldEvents)
+        {
+            op = EPOLL_CTL_ADD;
+        }
+
+        ev.data.fd = watcher.socket.handle;
+        ev.events = (events & (Event.read | Event.accept) ? EPOLLIN | EPOLLPRI : 0)
+                  | (events & Event.write ? EPOLLOUT : 0)
+                  | EPOLLET;
+
+        return epoll_ctl(fd, op, watcher.socket.handle, &ev) == 0;
+    }
+
+    /**
+     * Does the actual polling.
+     */
+    protected override void poll()
+    {
+        // Don't block
+        immutable timeout = cast(immutable int) blockTime.total!"msecs";
+        auto eventCount = epoll_wait(fd, events.ptr, maxEvents, timeout);
+
+        if (eventCount < 0)
+        {
+            if (errno != EINTR)
+            {
+                throw defaultAllocator.make!BadLoopException();
+            }
+            return;
+        }
+
+        for (auto i = 0; i < eventCount; ++i)
+        {
+            auto io = cast(IOWatcher) connections[events[i].data.fd];
+
+            if (io is null)
+            {
+                acceptConnections(connections[events[i].data.fd]);
+            }
+            else if (events[i].events & EPOLLERR)
+            {
+                kill(io, null);
+            }
+            else if (events[i].events & (EPOLLIN | EPOLLPRI | EPOLLHUP))
+            {
+                auto transport = cast(SelectorStreamTransport) io.transport;
+                assert(transport !is null);
+
+                SocketException exception;
+                try
+                {
+                    ptrdiff_t received;
+                    do
+                    {
+                        received = transport.socket.receive(io.output[]);
+                        io.output += received;
+                    }
+                    while (received);
+                }
+                catch (SocketException e)
+                {
+                    exception = e;
+                }
+                if (transport.socket.disconnected)
+                {
+                    kill(io, exception);
+                }
+                else if (io.output.length)
+                {
+                    swapPendings.insertBack(io);
+                }
+            }
+            else if (events[i].events & EPOLLOUT)
+            {
+                auto transport = cast(SelectorStreamTransport) io.transport;
+                assert(transport !is null);
+
+                transport.writeReady = true;
+                if (transport.input.length)
+                {
+                    feed(transport);
+                }
+            }
+        }
+    }
+
+    /**
+     * Returns: The blocking time.
+     */
+    override protected @property inout(Duration) blockTime()
+    inout @safe pure nothrow
+    {
+        return min(super.blockTime, 1.dur!"seconds");
+    }
+}

source/tanya/async/event/iocp.d

@@ -0,0 +1,294 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Copyright: Eugene Wissner 2016.
+ * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
+ *                  Mozilla Public License, v. 2.0).
+ * Authors: $(LINK2 mailto:belka@caraus.de, Eugene Wissner)
+ */
+module tanya.async.event.iocp;
+
+version (Windows):
+
+import tanya.container.buffer;
+import tanya.async.loop;
+import tanya.async.protocol;
+import tanya.async.transport;
+import tanya.async.watcher;
+import tanya.memory;
+import tanya.memory.mmappool;
+import tanya.network.socket;
+import core.sys.windows.basetyps;
+import core.sys.windows.mswsock;
+import core.sys.windows.winbase;
+import core.sys.windows.windef;
+import core.sys.windows.winsock2;
+
+class IOCPStreamTransport : StreamTransport
+{
+    private OverlappedConnectedSocket socket_;
+
+    private WriteBuffer input;
+
+    /**
+     * Creates new completion port transport.
+     * Params:
+     *     socket   = Socket.
+     */
+    this(OverlappedConnectedSocket socket)
+    in
+    {
+        assert(socket !is null);
+    }
+    body
+    {
+        socket_ = socket;
+        input = MmapPool.instance.make!WriteBuffer();
+    }
+
+    ~this()
+    {
+        MmapPool.instance.dispose(input);
+    }
+
+    @property inout(OverlappedConnectedSocket) socket() inout pure nothrow @safe @nogc
+    {
+        return socket_;
+    }
+
+    /**
+     * Write some data to the transport.
+     *
+     * Params:
+     *     data = Data to send.
+     */
+    void write(ubyte[] data)
+    {
+        immutable empty = input.length == 0;
+        input ~= data;
+        if (empty)
+        {
+            SocketState overlapped;
+            try
+            {
+                overlapped = MmapPool.instance.make!SocketState;
+                socket.beginSend(input[], overlapped);
+            }
+            catch (SocketException e)
+            {
+                MmapPool.instance.dispose(overlapped);
+                MmapPool.instance.dispose(e);
+            }
+        }
+    }
+}
+
+class IOCPLoop : Loop
+{
+    protected HANDLE completionPort;
+
+    protected OVERLAPPED overlap;
+
+    /**
+     * Initializes the loop.
+     */
+    this()
+    {
+        super();
+
+        completionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
+        if (!completionPort)
+        {
+            throw defaultAllocator.make!BadLoopException("Creating completion port failed");
+        }
+    }
+
+    /**
+     * Should be called if the backend configuration changes.
+     *
+     * Params:
+     *     watcher   = Watcher.
+     *     oldEvents = The events were already set.
+     *     events    = The events should be set.
+     *
+     * Returns: $(D_KEYWORD true) if the operation was successful.
+     */
+    override protected bool reify(ConnectionWatcher watcher,
+                                  EventMask oldEvents,
+                                  EventMask events)
+    {
+        SocketState overlapped;
+        if (!(oldEvents & Event.accept) && (events & Event.accept))
+        {
+            auto socket = cast(OverlappedStreamSocket) watcher.socket;
+            assert(socket !is null);
+
+            if (CreateIoCompletionPort(cast(HANDLE) socket.handle,
+                                       completionPort,
+                                       cast(ULONG_PTR) (cast(void*) watcher),
+                                       0) !is completionPort)
+            {
+                return false;
+            }
+
+            try
+            {
+                overlapped = MmapPool.instance.make!SocketState;
+                socket.beginAccept(overlapped);
+            }
+            catch (SocketException e)
+            {
+                MmapPool.instance.dispose(overlapped);
+                defaultAllocator.dispose(e);
+                return false;
+            }
+        }
+        if (!(oldEvents & Event.read) && (events & Event.read)
+            || !(oldEvents & Event.write) && (events & Event.write))
+        {
+            auto io = cast(IOWatcher) watcher;
+            assert(io !is null);
+
+            auto transport = cast(IOCPStreamTransport) io.transport;
+            assert(transport !is null);
+
+            if (CreateIoCompletionPort(cast(HANDLE) transport.socket.handle,
+                                       completionPort,
+                                       cast(ULONG_PTR) (cast(void*) watcher),
+                                       0) !is completionPort)
+            {
+                return false;
+            }
+
+            // Begin to read
+            if (!(oldEvents & Event.read) && (events & Event.read))
+            {
+                try
+                {
+                    overlapped = MmapPool.instance.make!SocketState;
+                    transport.socket.beginReceive(io.output[], overlapped);
+                }
+                catch (SocketException e)
+                {
+                    MmapPool.instance.dispose(overlapped);
+                    defaultAllocator.dispose(e);
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Does the actual polling.
+     */
+    override protected void poll()
+    {
+        DWORD lpNumberOfBytes;
+        ULONG_PTR key;
+        LPOVERLAPPED overlap;
+        immutable timeout = cast(immutable int) blockTime.total!"msecs";
+
+        auto result = GetQueuedCompletionStatus(completionPort,
+                                                &lpNumberOfBytes,
+                                                &key,
+                                                &overlap,
+                                                timeout);
+        if (result == FALSE && overlap == NULL)
+        {
+            return; // Timeout
+        }
+
+        auto overlapped = (cast(SocketState) ((cast(void*) overlap) - 8));
+        assert(overlapped !is null);
+        scope (failure)
+        {
+            MmapPool.instance.dispose(overlapped);
+        }
+
+        switch (overlapped.event)
+        {
+            case OverlappedSocketEvent.accept:
+                auto connection = cast(ConnectionWatcher) (cast(void*) key);
+                assert(connection !is null);
+
+                auto listener = cast(OverlappedStreamSocket) connection.socket;
+                assert(listener !is null);
+
+                auto socket = listener.endAccept(overlapped);
+                auto transport = MmapPool.instance.make!IOCPStreamTransport(socket);
+                auto io = MmapPool.instance.make!IOWatcher(transport, connection.protocol);
+
+                connection.incoming.insertBack(io);
+
+                reify(io, EventMask(Event.none), EventMask(Event.read, Event.write));
+
+                swapPendings.insertBack(connection);
+                listener.beginAccept(overlapped);
+                break;
+            case OverlappedSocketEvent.read:
+                auto io = cast(IOWatcher) (cast(void*) key);
+                assert(io !is null);
+                if (!io.active)
+                {
+                    MmapPool.instance.dispose(io);
+                    MmapPool.instance.dispose(overlapped);
+                    return;
+                }
+
+                auto transport = cast(IOCPStreamTransport) io.transport;
+                assert(transport !is null);
+
+                int received;
+                SocketException exception;
+                try
+                {
+                    received = transport.socket.endReceive(overlapped);
+                }
+                catch (SocketException e)
+                {
+                    exception = e;
+                }
+                if (transport.socket.disconnected)
+                {
+                    // We want to get one last notification to destroy the watcher
+                    transport.socket.beginReceive(io.output[], overlapped);
+                    kill(io, exception);
+                }
+                else if (received > 0)
+                {
+                    immutable full = io.output.free == received;
+
+                    io.output += received;
+                    // Receive was interrupted because the buffer is full. We have to continue
+                    if (full)
+                    {
+                        transport.socket.beginReceive(io.output[], overlapped);
+                    }
+                    swapPendings.insertBack(io);
+                }
+                break;
+            case OverlappedSocketEvent.write:
+                auto io = cast(IOWatcher) (cast(void*) key);
+                assert(io !is null);
+
+                auto transport = cast(IOCPStreamTransport) io.transport;
+                assert(transport !is null);
+
+                transport.input += transport.socket.endSend(overlapped);
+                if (transport.input.length)
+                {
+                    transport.socket.beginSend(transport.input[], overlapped);
+                }
+                else
+                {
+                    transport.socket.beginReceive(io.output[], overlapped);
+                }
+                break;
+            default:
+                assert(false, "Unknown event");
+        }
+    }
+}

source/tanya/async/event/kqueue.d

@@ -0,0 +1,349 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Copyright: Eugene Wissner 2016.
+ * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
+ *                  Mozilla Public License, v. 2.0).
+ * Authors: $(LINK2 mailto:belka@caraus.de, Eugene Wissner)
+ */
+module tanya.async.event.kqueue;
+
+version (OSX)
+{
+    version = MissingKevent;
+}
+else version (iOS)
+{
+    version = MissingKevent;
+}
+else version (TVOS)
+{
+    version = MissingKevent;
+}
+else version (WatchOS)
+{
+    version = MissingKevent;
+}
+else version (OpenBSD)
+{
+    version = MissingKevent;
+}
+else version (DragonFlyBSD)
+{
+    version = MissingKevent;
+}
+
+version (MissingKevent)
+{
+    extern (C):
+    nothrow:
+    @nogc:
+
+    import core.stdc.stdint;    // intptr_t, uintptr_t
+    import core.sys.posix.time; // timespec
+
+    enum : short
+    {
+        EVFILT_READ     =  -1,
+        EVFILT_WRITE    =  -2,
+        EVFILT_AIO      =  -3, /* attached to aio requests */
+        EVFILT_VNODE    =  -4, /* attached to vnodes */
+        EVFILT_PROC     =  -5, /* attached to struct proc */
+        EVFILT_SIGNAL   =  -6, /* attached to struct proc */
+        EVFILT_TIMER    =  -7, /* timers */
+        EVFILT_MACHPORT =  -8, /* Mach portsets */
+        EVFILT_FS       =  -9, /* filesystem events */
+        EVFILT_USER     = -10, /* User events */
+        EVFILT_VM       = -12, /* virtual memory events */
+        EVFILT_SYSCOUNT =  11
+    }
+
+    extern(D) void EV_SET(kevent_t* kevp, typeof(kevent_t.tupleof) args)
+    {
+        *kevp = kevent_t(args);
+    }
+
+    struct kevent_t
+    {
+        uintptr_t    ident; /* identifier for this event */
+        short       filter; /* filter for event */
+        ushort       flags;
+        uint        fflags;
+        intptr_t      data;
+        void        *udata; /* opaque user data identifier */
+    }
+
+    enum
+    {
+        /* actions */
+        EV_ADD      = 0x0001, /* add event to kq (implies enable) */
+        EV_DELETE   = 0x0002, /* delete event from kq */
+        EV_ENABLE   = 0x0004, /* enable event */
+        EV_DISABLE  = 0x0008, /* disable event (not reported) */
+
+        /* flags */
+        EV_ONESHOT  = 0x0010, /* only report one occurrence */
+        EV_CLEAR    = 0x0020, /* clear event state after reporting */
+        EV_RECEIPT  = 0x0040, /* force EV_ERROR on success, data=0 */
+        EV_DISPATCH = 0x0080, /* disable event after reporting */
+
+        EV_SYSFLAGS = 0xF000, /* reserved by system */
+        EV_FLAG1    = 0x2000, /* filter-specific flag */
+
+        /* returned values */
+        EV_EOF      = 0x8000, /* EOF detected */
+        EV_ERROR    = 0x4000, /* error, data contains errno */
+    }
+
+    int kqueue();
+    int kevent(int kq, const kevent_t *changelist, int nchanges,
+               kevent_t *eventlist, int nevents,
+               const timespec *timeout);
+}
+
+version (OSX)
+{
+    version = MacBSD;
+}
+else version (iOS)
+{
+    version = MacBSD;
+}
+else version (FreeBSD)
+{
+    version = MacBSD;
+    public import core.sys.freebsd.sys.event;
+}
+else version (OpenBSD)
+{
+    version = MacBSD;
+}
+else version (DragonFlyBSD)
+{
+    version = MacBSD;
+}
+
+version (MacBSD):
+
+import dlib.async.event.selector;
+import dlib.async.loop;
+import dlib.async.transport;
+import dlib.async.watcher;
+import dlib.memory;
+import dlib.memory.mmappool;
+import dlib.network.socket;
+import core.stdc.errno;
+import core.sys.posix.unistd;
+import core.sys.posix.sys.time;
+import core.time;
+import std.algorithm.comparison;
+
+class KqueueLoop : SelectorLoop
+{
+    protected int fd;
+    private kevent_t[] events;
+    private kevent_t[] changes;
+    private size_t changeCount;
+
+    /**
+     * Returns: Maximal event count can be got at a time
+     *          (should be supported by the backend).
+     */
+    override protected @property inout(uint) maxEvents() inout const pure nothrow @safe @nogc
+    {
+        return cast(uint) events.length;
+    }
+
+    this()
+    {
+        super();
+
+        if ((fd = kqueue()) == -1)
+        {
+            throw MmapPool.instance.make!BadLoopException("epoll initialization failed");
+        }
+        events = MmapPool.instance.makeArray!kevent_t(64);
+        changes = MmapPool.instance.makeArray!kevent_t(64);
+    }
+
+    /**
+     * Free loop internals.
+     */
+    ~this()
+    {
+        MmapPool.instance.dispose(events);
+        MmapPool.instance.dispose(changes);
+        close(fd);
+    }
+
+    private void set(socket_t socket, short filter, ushort flags)
+    {
+        if (changes.length <= changeCount)
+        {
+            MmapPool.instance.resizeArray(changes, changeCount + maxEvents);
+        }
+        EV_SET(&changes[changeCount],
+               cast(ulong) socket,
+               filter,
+               flags,
+               0U,
+               0L,
+               null);
+        ++changeCount;
+    }
+
+    /**
+     * Should be called if the backend configuration changes.
+     *
+     * Params:
+     *     watcher   = Watcher.
+     *     oldEvents = The events were already set.
+     *     events    = The events should be set.
+     *
+     * Returns: $(D_KEYWORD true) if the operation was successful.
+     */
+    override protected bool reify(ConnectionWatcher watcher,
+                                  EventMask oldEvents,
+                                  EventMask events)
+    {
+        if (events != oldEvents)
+        {
+            if (oldEvents & Event.read || oldEvents & Event.accept)
+            {
+                set(watcher.socket.handle, EVFILT_READ, EV_DELETE);
+            }
+            if (oldEvents & Event.write)
+            {
+                set(watcher.socket.handle, EVFILT_WRITE, EV_DELETE);
+            }
+        }
+        if (events & (Event.read | events & Event.accept))
+        {
+            set(watcher.socket.handle, EVFILT_READ, EV_ADD | EV_ENABLE);
+        }
+        if (events & Event.write)
+        {
+            set(watcher.socket.handle, EVFILT_WRITE, EV_ADD | EV_DISPATCH);
+        }
+        return true;
+    }
+
+    /**
+     * Does the actual polling.
+     */
+    protected override void poll()
+    {
+        timespec ts;
+        blockTime.split!("seconds", "nsecs")(ts.tv_sec, ts.tv_nsec);
+
+        if (changeCount > maxEvents) 
+        {
+            MmapPool.instance.resizeArray(events, changes.length);
+        }
+
+        auto eventCount = kevent(fd, changes.ptr, cast(int) changeCount, events.ptr, maxEvents, &ts);
+        changeCount = 0;
+
+        if (eventCount < 0)
+        {
+            if (errno != EINTR)
+            {
+                throw defaultAllocator.make!BadLoopException();
+            }
+            return;
+        }
+
+        for (int i; i < eventCount; ++i)
+        {
+            assert(connections.length > events[i].ident);
+
+            IOWatcher io = cast(IOWatcher) connections[events[i].ident];
+            // If it is a ConnectionWatcher. Accept connections.
+            if (io is null)
+            {
+                acceptConnections(connections[events[i].ident]);
+            }
+            else if (events[i].flags & EV_ERROR)
+            {
+                kill(io, null);
+            }
+            else if (events[i].filter == EVFILT_READ)
+            {
+                auto transport = cast(SelectorStreamTransport) io.transport;
+                assert(transport !is null);
+
+                SocketException exception;
+                try
+                {
+                    ptrdiff_t received;
+                    do
+                    {
+                        received = transport.socket.receive(io.output[]);
+                        io.output += received;
+                    }
+                    while (received);
+                }
+                catch (SocketException e)
+                {
+                    exception = e;
+                }
+                if (transport.socket.disconnected)
+                {
+                    kill(io, exception);
+                }
+                else if (io.output.length)
+                {
+                    swapPendings.insertBack(io);
+                }
+            }
+            else if (events[i].filter == EVFILT_WRITE)
+            {
+                auto transport = cast(SelectorStreamTransport) io.transport;
+                assert(transport !is null);
+
+                transport.writeReady = true;
+                if (transport.input.length)
+                {
+                    feed(transport);
+                }
+            }
+        }
+    }
+
+    /**
+     * Returns: The blocking time.
+     */
+    override protected @property inout(Duration) blockTime()
+    inout @safe pure nothrow
+    {
+        return min(super.blockTime, 1.dur!"seconds");
+    }
+
+    /**
+     * If the transport couldn't send the data, the further sending should
+     * be handled by the event loop.
+     *
+     * Params:
+     *     transport = Transport.
+     *     exception = Exception thrown on sending.
+     *
+     * Returns: $(D_KEYWORD true) if the operation could be successfully
+     *          completed or scheduled, $(D_KEYWORD false) otherwise (the
+     *          transport is be destroyed then).
+     */
+    protected override bool feed(SelectorStreamTransport transport, SocketException exception = null)
+    {
+        if (!super.feed(transport, exception))
+        {
+            return false;
+        }
+        if (!transport.writeReady)
+        {
+            set(transport.socket.handle, EVFILT_WRITE, EV_DISPATCH);
+            return true;
+        }
+        return false;
+    }
+}

source/tanya/async/event/selector.d

@@ -0,0 +1,266 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Copyright: Eugene Wissner 2016.
+ * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
+ *                  Mozilla Public License, v. 2.0).
+ * Authors: $(LINK2 mailto:belka@caraus.de, Eugene Wissner)
+ */
+module tanya.async.event.selector;
+
+version (Posix):
+
+import tanya.async.loop;
+import tanya.async.transport;
+import tanya.async.watcher;
+import tanya.container.buffer;
+import tanya.memory;
+import tanya.memory.mmappool;
+import tanya.network.socket;
+import core.sys.posix.netinet.in_;
+import core.stdc.errno;
+
+/**
+ * Transport for stream sockets.
+ */
+class SelectorStreamTransport : StreamTransport
+{
+    private ConnectedSocket socket_;
+
+    /// Input buffer.
+    package WriteBuffer input;
+
+    private SelectorLoop loop;
+
+    /// Received notification that the underlying socket is write-ready.
+    package bool writeReady;
+
+    /**
+     * Params:
+     *     loop     = Event loop.
+     *     socket   = Socket.
+     */
+    this(SelectorLoop loop, ConnectedSocket socket)
+    {
+        socket_ = socket;
+        this.loop = loop;
+        input = MmapPool.instance.make!WriteBuffer();
+    }
+
+    /**
+     * Close the transport and deallocate the data buffers.
+     */
+    ~this()
+    {
+        MmapPool.instance.dispose(input);
+    }
+
+    /**
+     * Returns: Transport socket.
+     */
+    inout(ConnectedSocket) socket() inout pure nothrow @safe @nogc
+    {
+        return socket_;
+    }
+
+    /**
+     * Write some data to the transport.
+     *
+     * Params:
+     *     data = Data to send.
+     */
+    void write(ubyte[] data)
+    {
+        if (!data.length)
+        {
+            return;
+        }
+        // Try to write if the socket is write ready.
+        if (writeReady)
+        {
+            ptrdiff_t sent;
+            SocketException exception;
+            try
+            {
+                sent = socket.send(data);
+                if (sent == 0)
+                {
+                    writeReady = false;
+                }
+            }
+            catch (SocketException e)
+            {
+                writeReady = false;
+                exception = e;
+            }
+            if (sent < data.length)
+            {
+                input ~= data[sent..$];
+                loop.feed(this, exception);
+            }
+        }
+        else
+        {
+            input ~= data;
+        }
+    }
+}
+
+abstract class SelectorLoop : Loop
+{
+    /// Pending connections.
+    protected ConnectionWatcher[] connections;
+
+    this()
+    {
+        super();
+        connections = MmapPool.instance.makeArray!ConnectionWatcher(maxEvents);
+    }
+
+    ~this()
+    {
+        foreach (ref connection; connections)
+        {
+            // We want to free only IOWatchers. ConnectionWatcher are created by the
+            // user and should be freed by himself.
+            auto io = cast(IOWatcher) connection;
+            if (io !is null)
+            {
+                MmapPool.instance.dispose(io);
+                connection = null;
+            }
+        }
+        MmapPool.instance.dispose(connections);
+    }
+
+    /**
+     * If the transport couldn't send the data, the further sending should
+     * be handled by the event loop.
+     *
+     * Params:
+     *     transport = Transport.
+     *     exception = Exception thrown on sending.
+     *
+     * Returns: $(D_KEYWORD true) if the operation could be successfully
+     *          completed or scheduled, $(D_KEYWORD false) otherwise (the
+     *          transport will be destroyed then).
+     */
+    protected bool feed(SelectorStreamTransport transport, SocketException exception = null)
+    {
+        while (transport.input.length && transport.writeReady)
+        {
+            try
+            {
+                ptrdiff_t sent = transport.socket.send(transport.input[]);
+                if (sent == 0)
+                {
+                    transport.writeReady = false;
+                }
+                else
+                {
+                    transport.input += sent;
+                }
+            }
+            catch (SocketException e)
+            {
+                exception = e;
+                transport.writeReady = false;
+            }
+        }
+        if (exception !is null)
+        {
+            auto watcher = cast(IOWatcher) connections[transport.socket.handle];
+            assert(watcher !is null);
+
+            kill(watcher, exception);
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Start watching.
+     *
+     * Params:
+     *     watcher = Watcher.
+     */
+    override void start(ConnectionWatcher watcher)
+    {
+        if (watcher.active)
+        {
+            return;
+        }
+
+        if (connections.length <= watcher.socket)
+        {
+            MmapPool.instance.resizeArray(connections, watcher.socket.handle + maxEvents / 2);
+        }
+        connections[watcher.socket.handle] = watcher;
+
+        super.start(watcher);
+    }
+
+    /**
+     * Accept incoming connections.
+     *
+     * Params:
+     *     connection = Connection watcher ready to accept.
+     */
+    package void acceptConnections(ConnectionWatcher connection)
+    in
+    {
+        assert(connection !is null);
+    }
+    body
+    {
+        while (true)
+        {
+            ConnectedSocket client;
+            try
+            {
+                client = (cast(StreamSocket) connection.socket).accept();
+            }
+            catch (SocketException e)
+            {
+                defaultAllocator.dispose(e);
+                break;
+            }
+            if (client is null)
+            {
+                break;
+            }
+
+            IOWatcher io;
+            auto transport = MmapPool.instance.make!SelectorStreamTransport(this, client);
+
+            if (connections.length >= client.handle)
+            {
+                io = cast(IOWatcher) connections[client.handle];
+            }
+            else
+            {
+                MmapPool.instance.resizeArray(connections, client.handle + maxEvents / 2);
+            }
+            if (io is null)
+            {
+                io = MmapPool.instance.make!IOWatcher(transport,
+                                                      connection.protocol);
+                connections[client.handle] = io;
+            }
+            else
+            {
+                io(transport, connection.protocol);
+            }
+
+            reify(io, EventMask(Event.none), EventMask(Event.read, Event.write));
+            connection.incoming.insertBack(io);
+        }
+
+        if (!connection.incoming.empty)
+        {
+            swapPendings.insertBack(connection);
+        }
+    }
+}