root/lang/c/partty/fdio/multiplexer_bsd_kqueue.h @ 3319

/*
 * FDIO
 *
 * Copyright (c) 2007 FURUHASHI Sadayuki
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#ifndef FDIO_MULTIPLEXER_BSD_KQUEUE_H__
#define FDIO_MULTIPLEXER_BSD_KQUEUE_H__ 1

#include "fdio/multiplexer_common.h"
#include <sys/event.h>  // kqueue
#include <sys/time.h>
#include <valarray>
#include <bitset>
#include <limits>

namespace FDIO {

template <bool oneshot, bool threadsafe>
class BSDKqueueMultiplexer {
public:
        typedef int fd_type;
        typedef short index_type;
        typedef enum {
                EVENT_IN  = EVFILT_READ,
                EVENT_OUT = EVFILT_WRITE,
        } observe_type;
        typedef short observe_bitmap_t;
public:
        class BSDKqueueEvents {
        public:
                struct Event {
                        friend class BSDKqueueMultiplexer;
                        Event(const struct kevent& kev) :
                                fd(kev.ident),
                                events(kev.filter),
                                observed( (short)(int)kev.udata ) {}
                                        // void* -> shortのキャストは危険だが、たぶん動く
                        Event() : fd(-1), events(0) {}
                        int fd;
                        observe_bitmap_t events;
                private:
                        short observed;
                };
                typedef Event ev_t;
        public:
                Event next(void)
                {
                        if( m_current < m_num ) {
                                return Event(m_results[m_current++]);
                        } else {
                                return Event();
                        }
                }
        public:
                BSDKqueueEvents(const std::valarray<struct kevent>& results, int num) :
                                        m_current(0),
                                        m_num(num),
                                        m_results(results)
                {
                        if( num < 0 && errno != EINTR ) {
                                throw MultiplexerWaitException(errno, "kevent() wait");
                        }
                }
        private:
                size_t m_current;
                const size_t m_num;
                const std::valarray<struct kevent>& m_results;
        private:
                BSDKqueueEvents();
        };
        typedef BSDKqueueEvents events_type;
private:
        static const int MAX_EVENTS = 8;
public:
        BSDKqueueMultiplexer() : m_results(MAX_EVENTS)
        {
                if( (m_kqueue_fd = kqueue()) < 0 ) {
                        throw MultiplexerInitializeException(errno, "kqueue() initialize");
                }
        }

        index_type add(int fd, observe_bitmap_t events)
        {
                struct kevent kev;

                EV_SET(&kev, fd, events, EV_ADD | (oneshot ? EV_ONESHOT : 0), 0, 0, (void*)events);
                        // short -> void* のキャストは危険だが、たぶん動く

                if( kevent(m_kqueue_fd, &kev, 1, NULL, 0, NULL) < 0 ) {
                        throw MultiplexerAddException(errno, "kevent() add");
                }

                return events;

                /*
                struct timespec ts;
                ts.tv_sec  = 0;
                ts.tv_nsec = 0;
                */
        }

        void reactivate(index_type index, int fd, observe_bitmap_t events)
        {
                struct kevent kev;

                EV_SET(&kev, fd, events, EV_ADD | (oneshot ? EV_ONESHOT : 0), 0, 0, (void*)events);
                        // short -> void* のキャストは危険だが、たぶん動く

                if( kevent(m_kqueue_fd, &kev, 1, NULL, 0, NULL) < 0 ) {
                        throw MultiplexerReactivateException(errno, "kevent() reactivate");
                }

                /*
                struct timespec ts;
                ts.tv_sec  = 0;
                ts.tv_nsec = 0;
                */
        }
        void reactivate(typename events_type::ev_t ev, observe_bitmap_t events)
        {
                reactivate(ev.observed, ev.fd, events);
        }

        void remove(index_type index, int fd)
        {
                if( index & EVFILT_READ && index & EVFILT_WRITE ) {
                        struct kevent kev[2];
                        EV_SET(&kev[0], fd, EVFILT_READ,  EV_DELETE, 0, 0, NULL);
                        EV_SET(&kev[1], fd, EVFILT_WRITE, EV_DELETE, 0, 0, NULL);
                        if( kevent(m_kqueue_fd, kev, 2, NULL, 0, NULL) < 0 ) {
                                throw MultiplexerRemoveException(errno, "kevent() remove");
                        }
                } else {
                        struct kevent kev;
                        EV_SET(&kev, fd, index, EV_DELETE, 0, 0, NULL);
                        if( kevent(m_kqueue_fd, &kev, 1, NULL, 0, NULL) < 0 ) {
                                throw MultiplexerRemoveException(errno, "kevent() remove");
                        }
                }
        }

        void remove(typename events_type::ev_t ev)
        {
                remove(ev.observed, ev.fd);
        }

        events_type wait(int timeout_msec)
        {
                struct timespec ts;
                ts.tv_sec  = timeout_msec / 1000;
                ts.tv_nsec = (timeout_msec % 1000) * 1000000;

                return BSDKqueueEvents( 
                                m_results,
                                kevent(m_kqueue_fd, NULL, 0, &m_results[0], m_results.size(), &ts)
                                );
        }

        events_type wait(void)
        {
                return BSDKqueueEvents( 
                                m_results,
                                kevent(m_kqueue_fd, NULL, 0, &m_results[0], m_results.size(), NULL)
                                );
        }

private:
        int m_kqueue_fd;
        std::valarray<struct kevent> m_results;
};


}  // namespace FDIO

#endif /* multiplexer_bsd_kqueue.h */