Changeset 6514 for lang/c

Timestamp:

02/10/08 23:04:38 (5 years ago)

Author:

frsyuki

Message:

lang/c/mpio: changed event::wait() interface and added buffered_kqueue system

Location:

lang/c/mpio/trunk/mp

Files:

• dispatch.h (modified) (1 diff)
• event.h (modified) (1 diff)
• event_class.h (modified) (1 diff)
• event_impl.h (modified) (4 diffs)
• io.erb.h (modified) (1 diff)
• system/buffered_kqueue.h (added)
• system/buffered_kqueue_impl.h (added)
• system/epoll.h (modified) (1 diff)
• system/epoll_impl.h (modified) (2 diffs)
• system/kqueue.h (modified) (2 diffs)
• system/kqueue_impl.h (modified) (4 diffs)
• system/select.h (modified) (1 diff)
• system/select_impl.h (modified) (3 diffs)

lang/c/mpio/trunk/mp/dispatch.h

@@ -53 +53 @@
         short event;
         int ret;
-        typename event_t::backlog* result;
         while(1) {
-                if( (ret = m_event.wait(&result)) < 0 ) { return ret; }
-                while( result->next(&fd, &event, &pcb) ) {
+                if( (ret = m_event.wait()) < 0 ) { return ret; }
+                while( m_event.next(&fd, &event, &pcb) ) {
                         pcb->callback(fd, event, pcb->data);
                 }

lang/c/mpio/trunk/mp/event.h

@@ -11 +11 @@
 #      define MP_SYSTEM epoll
 #    elif defined(__APPLE__) && defined(__MACH__)
-#      define MP_SYSTEM kqueue
+//#      define MP_SYSTEM kqueue   // FIXME doesn't work
+#      define MP_SYSTEM select
+//#    elif defined(BSD)           // FIXME
+//#      define MP_SYSTEM kqueue
 #    else
 #      define MP_SYSTEM select

lang/c/mpio/trunk/mp/event_class.h

@@ -11 +11 @@
 public:
         typedef Data data_t;
-        typedef system< event<Data> > system_t;
-        typedef typename system_t::backlog backlog;
 public:
         event(size_t initial_length = 8);
-        int add(int fd, short event, data_t data);
-        int remove(int fd, short event);
-        int wait(backlog** rback);
-        int wait(backlog** rback, int timeout_msec);
-        data_t& data(int fd);
-        size_t size(void);
+        inline int add(int fd, short event, data_t data);
+        inline int remove(int fd, short event);
+        inline int wait(void);
+        inline int wait(int timeout_msec);
+        inline bool next(int* fd, short* revent);
+        inline bool next(int* fd, short* revent, data_t** data);
+        inline data_t& data(int fd);
 private:
-        system_t m_system;
+        system m_system;
         std::vector<data_t> m_events;
+private:
+        event(const event&);
+};
+
+
+template <>
+class event<void> {
+public:
+        typedef void data_t;
+public:
+        event(size_t initial_length = 8);
+        inline int add(int fd, short event);
+        inline int remove(int fd, short event);
+        inline int wait(void);
+        inline int wait(int timeout_msec);
+        inline bool next(int* fd, short* revent);
+private:
+        system m_system;
 private:
         event(const event&);

lang/c/mpio/trunk/mp/event_impl.h

@@ -7 +7 @@
 template <typename Data>
 event<Data>::event(size_t initial_length) :
-        m_system(this), m_events(initial_length) {}
+        m_events(initial_length) {}
+event<void>::event(size_t initial_length) {}
 
 template <typename Data>
@@ -18 +19 @@
         return m_system.add(fd, event);
 }
+int event<void>::add(int fd, short event)
+{
+        return m_system.add(fd, event);
+}
 
 template <typename Data>
@@ -24 +29 @@
         return m_system.remove(fd, event);
 }
-
-template <typename Data>
-int event<Data>::wait(backlog** rback)
+int event<void>::remove(int fd, short event)
 {
-        return m_system.wait(rback);
+        return m_system.remove(fd, event);
 }
 
 template <typename Data>
-int event<Data>::wait(backlog** rback, int timeout_msec)
+int event<Data>::wait(void)
 {
-        return m_system.wait(rback, timeout_msec);
+        return m_system.wait();
+}
+int event<void>::wait(void)
+{
+        return m_system.wait();
+}
+
+template <typename Data>
+int event<Data>::wait(int timeout_msec)
+{
+        return m_system.wait(timeout_msec);
+}
+int event<void>::wait(int timeout_msec)
+{
+        return m_system.wait(timeout_msec);
+}
+
+template <typename Data>
+bool event<Data>::next(int* fd, short* revent)
+{
+        return m_system.next(fd, revent);
+}
+bool event<void>::next(int* fd, short* revent)
+{
+        return m_system.next(fd, revent);
+}
+
+template <typename Data>
+bool event<Data>::next(int* fd, short* revent, data_t** data)
+{
+        if( m_system.next(fd, revent) ) {
+                *data = &m_events[*fd];
+                return true;
+        }
+        return false;
 }
 
@@ -43 +80 @@
 }
 
-template <typename Data>
-size_t event<Data>::size(void)
-{
-        return m_events.size();
-}
-
 
 }  // namespace mp

lang/c/mpio/trunk/mp/io.erb.h

@@ -166 +166 @@
         short event;
         int ret;
-        typename event_t::backlog* result;
         while(1) {
-                if( (ret = m_event.wait(&result)) < 0 ) { return ret; }
-                while( result->next(&fd, &event, &ed) ) {
+                if( (ret = m_event.wait()) < 0 ) { return ret; }
+                while( m_event.next(&fd, &event, &ed) ) {
                         ios::next_t next = (*ed->ios_callback)(ed->ios_obj, fd, event);
                         int next_fd = MP_IO_NEXT_FD(next);

lang/c/mpio/trunk/mp/system/epoll.h

@@ -15 +15 @@
 const static short EV_WRITE = EPOLLOUT;
 
-template <typename Framework>
 class system {
-public:
-        struct backlog {
-                backlog() {}
-                backlog(Framework* framework) : _framework(framework) {}
-                bool next(int* rfd, short* revent, typename Framework::data_t** rdata);
-                typename Framework::data_t& next(void);
-                int _count;
-                int _num;
-                struct kevent _results[MP_EVENT_EPOLL_MAX_RESULT];
-                Framework* _framework;
-        };
 public:
         system();
         int add(int fd, short event);
         int remove(int fd, short event);
-        int wait(Framework* framework, backlog** rback);
-        int wait(Framework* framework, backlog** rback, int timeout_msec);
+        int wait(void);
+        int wait(int timeout_msec);
+private:
+        struct backlog {
+                backlog() {}
+                bool next(int* rfd, short* revent);
+                int count;
+                int num;
+                struct epoll_event results[MP_EVENT_EPOLL_MAX_RESULT];
+        };
+        backlog m_backlog;
 private:
         int m_epfd;
-        backlog m_backlog;
 };
 

lang/c/mpio/trunk/mp/system/epoll_impl.h

@@ -5 +5 @@
 
 
-template <typename Framework>
-system<Framework>::system()
+system::system()
 {
         m_epfd = epoll_create(MP_EVENT_EPOLL_MAX_RESULT);
 }
 
-template <typename Framework>
-int system<Framework>::add(int fd, short event)
+system::backlog::backlog() : count(0), num(0) {}
+
+int system::add(int fd, short event)
 {
         struct epoll_event ep;
@@ -20 +20 @@
 }
 
-template <typename Framework>
-int system<Framework>::remove(int fd, short event)
+int system::remove(int fd, short event)
 {
         return epoll_ctl(m_epfd, EPOLL_CTL_DEL, fd, NULL);
 }
 
-template <typename Framework>
-int system<Framework>::wait(Framework* framework, backlog** rback)
+int system::wait()
 {
-        *rback = &m_backlog;
-        return m_backlog._num = epoll_wait(m_epfd, m_backlog._results, sizeof(m_backlog._results), -1);
+        return m_backlog.num = epoll_wait(m_epfd, m_backlog.results, MP_EVENT_EPOLL_MAX_RESULT, -1);
 }
 
-template <typename Framework>
-int system<Framework>::wait(Framework* framework, backlog** rback, int timeout_msec)
+int system::wait(int timeout_msec)
 {
-        *rback = &m_backlog;
-        return m_backlog._num = epoll_wait(m_epfd, m_backlog._results, sizeof(m_backlog._results), timeout_msec);
+        return m_backlog.num = epoll_wait(m_epfd, m_backlog.results, MP_EVENT_EPOLL_MAX_RESULT, timeout_msec);
 }
 
-template <typename Framework>
-bool system<Framework>::backlog::next(int* rfd, short* revent, typename Framework::data_t** rdata)
+bool system::next(int* rfd, short* revent)
 {
-        if( _count >= _num ) { return false; }
-        struct epoll_event* const ep = &_results[_count];
+        if( m_backlog.count >= m_backlog.num ) { return false; }
+        struct epoll_event* const ep = &m_backlog.results[m_backlog.count];
         *rfd = ep->data.fd;
         *revent = ep->events;
-        *rdata = &_framework->data(*rfd);
         return true;
 }

lang/c/mpio/trunk/mp/system/kqueue.h

@@ -16 +16 @@
 const static short EV_WRITE = EVFILT_WRITE;
 
-template <typename Framework>
 class system {
 public:
-        struct backlog {
-                backlog(Framework* framework) : _framework(framework) {}
-                bool next(int* rfd, short* revent, typename Framework::data_t** rdata);
-                typename Framework::data_t& next(void);
-                int _count;
-                int _num;
-                struct kevent _results[MP_EVENT_KQUEUE_MAX_RESULT];
-                Framework* _framework;
-        };
-public:
-        system(Framework* framework);
+        system();
         int add(int fd, short event);
         int remove(int fd, short event);
-        int wait(backlog** rback);
-        int wait(backlog** rback, int timeout_msec);
+        int wait(void);
+        int wait(int timeout_msec);
+        bool next(int* rfd, short* revent);
+private:
+        struct backlog {
+                backlog();
+                int count;
+                int num;
+                struct kevent results[MP_EVENT_KQUEUE_MAX_RESULT];
+        };
+        backlog m_backlog;
 private:
         int m_kqfd;
-        backlog m_backlog;
 };
 
@@ -43 +40 @@
 
 #endif /* mp/system/kqueue.h */
+

lang/c/mpio/trunk/mp/system/kqueue_impl.h

@@ -5 +5 @@
 
 
-template <typename Framework>
-system<Framework>::system(Framework* framework) : m_backlog(framework)
+system::system()
 {
         m_kqfd = kqueue();
 }
 
-template <typename Framework>
-int system<Framework>::add(int fd, short event)
+system::backlog::backlog() : count(0), num(0) {}
+
+
+int system::add(int fd, short event)
 {
         struct kevent kev;
@@ -19 +20 @@
 }
 
-template <typename Framework>
-int system<Framework>::remove(int fd, short event)
+int system::remove(int fd, short event)
 {
         if( event & EVFILT_READ && event & EVFILT_WRITE ) {
@@ -27 +27 @@
                 EV_SET(&kev[1], fd, EVFILT_WRITE, EV_DELETE, 0, 0, NULL);
                 return kevent(m_kqfd, kev, 2, NULL, 0, NULL);
-        } else {
-                struct kevent kev;
-                EV_SET(&kev, fd, event, EV_ADD, 0, 0, NULL);
-                return kevent(m_kqfd, &kev, 1, NULL, 0, NULL);
         }
-        return -1;  /* never come here */
+        struct kevent kev;
+        EV_SET(&kev, fd, event, EV_ADD, 0, 0, NULL);
+        return kevent(m_kqfd, &kev, 1, NULL, 0, NULL);
 }
 
-template <typename Framework>
-int system<Framework>::wait(backlog** rback)
+int system::wait()
 {
-        *rback = &m_backlog;
-        m_backlog._count = 0;
-        return m_backlog._num = kevent(m_kqfd, NULL, 0, m_backlog._results, sizeof(m_backlog._results), NULL);
+        m_backlog.count = 0;
+        return m_backlog.num = kevent(m_kqfd, NULL, 0, m_backlog.results, MP_EVENT_KQUEUE_MAX_RESULT, NULL);
 }
 
-template <typename Framework>
-int system<Framework>::wait(backlog** rback, int timeout_msec)
+int system::wait(int timeout_msec)
 {
         struct timespec ts;
         ts.tv_sec  = timeout_msec / 1000;
         ts.tv_nsec = (timeout_msec % 1000) * 1000000;
-        *rback = &m_backlog;
-        m_backlog._count = 0;
-        return m_backlog._num = kevent(m_kqfd, NULL, 0, m_backlog._results, sizeof(m_backlog._results), &ts);
+        m_backlog.count = 0;
+        return m_backlog.num = kevent(m_kqfd, NULL, 0, m_backlog.results, MP_EVENT_KQUEUE_MAX_RESULT, &ts);
 }
 
-template <typename Framework>
-bool system<Framework>::backlog::next(int* rfd, short* revent, typename Framework::data_t** rdata)
+bool system::next(int* rfd, short* revent)
 {
-        if( _count >= _num ) { return false; }
-        struct kevent* const kev = &_results[_count];
-        ++_count;
+        if( m_backlog.count >= m_backlog.num ) { return false; }
+        struct kevent* const kev = &m_backlog.results[m_backlog.count];
+        ++m_backlog.count;
         *rfd = kev->ident;
         *revent = kev->filter;
-        _framework->data(*rfd);
-        *rdata = &_framework->data(*rfd);
         return true;
 }
@@ -71 +62 @@
 
 #endif /* mp/system/kqueue_impl.h */
+

lang/c/mpio/trunk/mp/system/select.h

@@ -12 +12 @@
 const static short EV_WRITE = 0x02;
 
-template <typename Framework>
 class system {
 public:
-        struct backlog {
-                backlog(Framework* framework) : _framework(framework) {}
-                bool next(int* rfd, short* revent, typename Framework::data_t** rdata);
-                typename Framework::data_t& next(void);
-                fd_set _readset;
-                fd_set _writeset;
-                fd_set* _source_readset;
-                fd_set* _source_writeset;
-                int _nfd;
-                int _count;
-                int _num;
-                int _size;
-                Framework* _framework;
-        };
-public:
-        system(Framework* framework);
+        system();
         int add(int fd, short event);
         int remove(int fd, short event);
-        int wait(backlog** rback);
-        int wait(backlog** rback, int timeout_msec);
+        int wait(void);
+        int wait(int timeout_msec);
+        bool next(int* rfd, short* revent);
+private:
+        struct backlog {
+                backlog();
+                int nfd;
+                int count;
+                int size;
+                int num;
+                fd_set readset;
+                fd_set writeset;
+        };
+        backlog m_backlog;
 private:
         int m_maxfd;
         fd_set m_readset;
         fd_set m_writeset;
-        backlog m_backlog;
         // FIXME: selectの第一引数が必要
 };

lang/c/mpio/trunk/mp/system/select_impl.h

@@ -4 +4 @@
 namespace mp {
 
-template <typename Framework>
-system<Framework>::system(Framework* framework) : m_backlog(framework)
+
+system::system() : m_maxfd(0)
 {
-        m_maxfd = 0;
         FD_ZERO(&m_readset);
         FD_ZERO(&m_writeset);
 }
 
-template <typename Framework>
-int system<Framework>::add(int fd, short event)
+system::backlog::backlog() : nfd(0), count(0), size(0), num(0) {}
+
+int system::add(int fd, short event)
 {
         if( fd > m_maxfd ) { m_maxfd = fd; }
@@ -25 +25 @@
 }
 
-template <typename Framework>
-int system<Framework>::remove(int fd, short event)
+int system::remove(int fd, short event)
 {
-        // FIXME m_maxfdはどすうる？m_backlog._framework->size();
+        // FIXME m_maxfdはどすうる？m_framework->size();
         FD_CLR(fd, &m_readset);
         FD_CLR(fd, &m_writeset);
@@ -34 +33 @@
 }
 
-template <typename Framework>
-int system<Framework>::wait(backlog** rback)
+int system::wait(void)
 {
-        FD_COPY(&m_readset,  &m_backlog._readset);
-        FD_COPY(&m_writeset, &m_backlog._writeset);
-        m_backlog._size = m_maxfd+1;
-        *rback = &m_backlog;
-        m_backlog._count = 0;
-        m_backlog._nfd = 0;
-        return m_backlog._num = select(m_backlog._size, &m_backlog._readset, &m_backlog._writeset, NULL, NULL);
+        FD_COPY(&m_readset,  &m_backlog.readset);
+        FD_COPY(&m_writeset, &m_backlog.writeset);
+        m_backlog.nfd = 0;
+        m_backlog.count = 0;
+        m_backlog.size = m_maxfd+1;
+        return m_backlog.num = select(m_backlog.size, &m_backlog.readset, &m_backlog.writeset, NULL, NULL);
 }
 
-template <typename Framework>
-int system<Framework>::wait(backlog** rback, int timeout_msec)
+int system::wait(int timeout_msec)
 {
         struct timeval tv;
         tv.tv_sec = timeout_msec / 1000;
         tv.tv_usec = (timeout_msec % 1000) * 1000;
-        FD_COPY(&m_readset,  &m_backlog._readset);
-        FD_COPY(&m_writeset, &m_backlog._writeset);
-        m_backlog._size = m_maxfd+1;
-        *rback = &m_backlog;
-        m_backlog._count = 0;
-        m_backlog._nfd = 0;
-        return m_backlog._num = select(m_backlog._size, &m_backlog._readset, &m_backlog._writeset, NULL, &tv);
+        FD_COPY(&m_readset,  &m_backlog.readset);
+        FD_COPY(&m_writeset, &m_backlog.writeset);
+        m_backlog.nfd = 0;
+        m_backlog.count = 0;
+        m_backlog.size = m_maxfd+1;
+        return m_backlog.num = select(m_backlog.size, &m_backlog.readset, &m_backlog.writeset, NULL, &tv);
 }
 
-template <typename Framework>
-bool system<Framework>::backlog::next(int* rfd, short* revent, typename Framework::data_t** rdata)
+bool system::next(int* rfd, short* revent)
 {
-        if( _count >= _num ) { return false; }
-        while( _nfd < _size ) {
+        if( m_backlog.count >= m_backlog.num ) { return false; }
+        while( m_backlog.nfd < m_backlog.size ) {
                 short event = 0;
-                if( FD_ISSET(_nfd, &_readset) ) {
+                if( FD_ISSET(m_backlog.nfd, &m_backlog.readset) ) {
                         event |= EV_READ;
                 }
-                if( FD_ISSET(_nfd, &_writeset) ) {
+                if( FD_ISSET(m_backlog.nfd, &m_backlog.writeset) ) {
                         event |= EV_WRITE;
                 }
                 if( event != 0 ) {
-                        *rfd = _nfd;
+                        *rfd = m_backlog.nfd;
                         *revent = event;
-                        *rdata = &_framework->data(_nfd);
-                        ++_nfd;
-                        ++_count;
+                        ++m_backlog.nfd;
+                        ++m_backlog.count;
                         return true;
                 }
-                ++_nfd;
+                ++m_backlog.nfd;
         }
         return false;