import java.nio.channels.ClosedSelectorException;

import java.nio.channels.SelectableChannel;

import java.nio.channels.SelectionKey;

import java.nio.channels.Selector;

import java.nio.channels.spi.SelectorProvider;

import java.util.ArrayDeque;

import java.util.BitSet;

import java.util.Deque;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.concurrent.TimeUnit;

import static sun.nio.ch.EPoll.EPOLLIN;

import static sun.nio.ch.EPoll.EPOLL_CTL_ADD;

import static sun.nio.ch.EPoll.EPOLL_CTL_DEL;

import static sun.nio.ch.EPoll.EPOLL_CTL_MOD;

 * Linux epoll based Selector implementation

class EPollSelectorImpl extends SelectorImpl {

    // maximum number of events to poll in one call to epoll_wait

    private static final int NUM_EPOLLEVENTS = Math.min(IOUtil.fdLimit(), 1024);

    // epoll file descriptor

    private final int epfd;

    // address of poll array when polling with epoll_wait

    private final long pollArrayAddress;

    // file descriptors used for interrupt

    // maps file descriptor to selection key, synchronize on selector

    private final Map<Integer, SelectionKeyImpl> fdToKey = new HashMap<>();

    // file descriptors registered with epoll, synchronize on selector

    private final BitSet registered = new BitSet();

    // pending new registrations/updates, queued by implRegister and putEventOps

    private final Object updateLock = new Object();

    private final Deque<SelectionKeyImpl> newKeys = new ArrayDeque<>();

    private final Deque<SelectionKeyImpl> updateKeys = new ArrayDeque<>();

    private final Deque<Integer> updateOps = new ArrayDeque<>();

    // interrupt triggering and clearing

    private boolean interruptTriggered;

        this.epfd = EPoll.create();

        this.pollArrayAddress = EPoll.allocatePollArray(NUM_EPOLLEVENTS);

            long fds = IOUtil.makePipe(false);

            this.fd0 = (int) (fds >>> 32);

            this.fd1 = (int) fds;

        } catch (IOException ioe) {

            EPoll.freePollArray(pollArrayAddress);

            FileDispatcherImpl.closeIntFD(epfd);

            throw ioe;

        // register one end of the socket pair for wakeups

        EPoll.ctl(epfd, EPOLL_CTL_ADD, fd0, EPOLLIN);

        if (!isOpen())

        assert Thread.holdsLock(this);

        processUpdateQueue();

            // epoll_wait timeout is int

            int to = (int) Math.min(timeout, Integer.MAX_VALUE);

            boolean timedPoll = (to > 0);

            do {

                long startTime = timedPoll ? System.nanoTime() : 0;

                numEntries = EPoll.wait(epfd, pollArrayAddress, NUM_EPOLLEVENTS, to);

                if (numEntries == IOStatus.INTERRUPTED && timedPoll) {

                    // timed poll interrupted so need to adjust timeout

                    long adjust = System.nanoTime() - startTime;

                    to -= TimeUnit.MILLISECONDS.convert(adjust, TimeUnit.NANOSECONDS);

                    if (to <= 0) {

                        // timeout expired so no retry

                        numEntries = 0;

                    }

                }

            } while (numEntries == IOStatus.INTERRUPTED);

            assert IOStatus.check(numEntries);

     * Process new registrations and changes to the interest ops.

     */

    private void processUpdateQueue() {

        assert Thread.holdsLock(this);

        synchronized (updateLock) {

            SelectionKeyImpl ski;

            // new registrations

            while ((ski = newKeys.pollFirst()) != null) {

                if (ski.isValid()) {

                    SelChImpl ch = ski.channel;

                    int fd = ch.getFDVal();

                    SelectionKeyImpl previous = fdToKey.put(fd, ski);

                    assert previous == null;

                    assert registered.get(fd) == false;

                }

            }

            // changes to interest ops

            assert updateKeys.size() == updateOps.size();

            while ((ski = updateKeys.pollFirst()) != null) {

                int ops = updateOps.pollFirst();

                int fd = ski.channel.getFDVal();

                if (ski.isValid() && fdToKey.containsKey(fd)) {

                    if (registered.get(fd)) {

                        if (ops == 0) {

                            // remove from epoll

                            EPoll.ctl(epfd, EPOLL_CTL_DEL, fd, 0);

                            registered.clear(fd);

                        } else {

                            // modify events

                            EPoll.ctl(epfd, EPOLL_CTL_MOD, fd, ops);

                        }

                    } else if (ops != 0) {

                        // add to epoll

                        EPoll.ctl(epfd, EPOLL_CTL_ADD, fd, ops);

                        registered.set(fd);

                    }

                }

            }

        }

    }

    /**

        assert Thread.holdsLock(this);

        assert Thread.holdsLock(nioSelectedKeys());

            long event = EPoll.getEvent(pollArrayAddress, i);

            int fd = EPoll.getDescriptor(event);

            if (fd == fd0) {

                SelectionKeyImpl ski = fdToKey.get(fd);

                    int rOps = EPoll.getEvents(event);

        assert Thread.holdsLock(this);

        assert Thread.holdsLock(nioKeys());

        FileDispatcherImpl.closeIntFD(epfd);

        EPoll.freePollArray(pollArrayAddress);

        assert Thread.holdsLock(nioKeys());

        synchronized (updateLock) {

            newKeys.addLast(ski);

        }

        assert !ski.isValid();

        assert Thread.holdsLock(this);

        assert Thread.holdsLock(nioKeys());

        assert Thread.holdsLock(nioSelectedKeys());

        int fd = ski.channel.getFDVal();

        fdToKey.remove(fd);

        if (registered.get(fd)) {

            EPoll.ctl(epfd, EPOLL_CTL_DEL, fd, 0);

            registered.clear(fd);

        }

        selectedKeys.remove(ski);

        // remove from channel's key set

            ((SelChImpl) selch).kill();

        synchronized (updateLock) {

            updateOps.addLast(ops);   // ops first in case adding the key fails

            updateKeys.addLast(ski);

        }

                try {

                    IOUtil.write1(fd1, (byte)0);

                } catch (IOException ioe) {

                    throw new InternalError(ioe);

                }