Changeset 6633

Show
Ignore:
Timestamp:
02/13/08 17:48:48 (5 years ago)
Author:
frsyuki
Message:

lang/c/mpio: added event::modify() interface

Location:
lang/c/mpio/trunk/mp
Files:
12 modified

Legend:

Unmodified
Added
Removed

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

    r6514 r6633  
    3030 
    3131 
     32template <> 
     33class dispatch<void> { 
     34public: 
     35        typedef Data data_t; 
     36        typedef std::function<void (int, short)> callback_t; 
     37public: 
     38        dispatch(size_t initial_length = 8); 
     39        int add(int fd, short event, callback_t callback); 
     40        int remove(int fd, short event); 
     41        int run(void); 
     42private: 
     43        struct cb_t { 
     44                cb_t() {} 
     45                cb_t(callback_t c) : callback(c) {} 
     46                callback_t callback; 
     47        }; 
     48        typedef event<cb_t> event_t; 
     49        event_t m_event; 
     50}; 
     51 
    3252 
    3353template <typename Data> 
    3454dispatch<Data>::dispatch(size_t initial_length) : m_event(initial_length) {} 
     55dispatch<void>::dispatch(size_t initial_length) : m_event(initial_length) {} 
    3556 
    3657template <typename Data> 
    … …  
    3960        return m_event.add(fd, event, cb_t(callback, data)); 
    4061} 
     62int dispatch<void>::add(int fd, short event, callback_t callback) 
     63{ 
     64        return m_event.add(fd, event, cb_t(callback)); 
     65} 
     66 
    4167 
    4268template <typename Data> 
    4369int dispatch<Data>::remove(int fd, short event) 
     70{ 
     71        return m_event.remove(fd, event); 
     72} 
     73int dispatch<void>::remove(int fd, short event) 
    4474{ 
    4575        return m_event.remove(fd, event); 
    … …  
    6090        } 
    6191} 
     92int dispatch<void>::run(void) 
     93{ 
     94        cb_t* pcb; 
     95        int fd; 
     96        short event; 
     97        int ret; 
     98        while(1) { 
     99                if( (ret = m_event.wait()) < 0 ) { return ret; } 
     100                while( m_event.next(&fd, &event, &pcb) ) { 
     101                        pcb->callback(fd, event); 
     102                } 
     103        } 
     104} 
    62105 
    63106 

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

    r6514 r6633  
    1414        event(size_t initial_length = 8); 
    1515        inline int add(int fd, short event, data_t data); 
    16         inline int remove(int fd, short event); 
     16        inline int remove(int fd, short oldevent); 
     17        inline int modify(int fd, short oldevent, short newevent); 
    1718        inline int wait(void); 
    1819        inline int wait(int timeout_msec); 
    … …  
    3536        event(size_t initial_length = 8); 
    3637        inline int add(int fd, short event); 
    37         inline int remove(int fd, short event); 
     38        inline int remove(int fd, short oldevent); 
     39        inline int modify(int fd, short oldevent, short newevent); 
    3840        inline int wait(void); 
    3941        inline int wait(int timeout_msec); 

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

    r6514 r6633  
    1414{ 
    1515        if( static_cast<size_t>(fd) >= m_events.size() ) { 
    16                 m_events.resize( m_events.size() * 2 ); 
     16                m_events.resize(fd + 1); 
     17                m_events.resize(m_events.capacity()); 
    1718        } 
    1819        m_events[fd] = data; 
    … …  
    2526 
    2627template <typename Data> 
    27 int event<Data>::remove(int fd, short event) 
     28int event<Data>::remove(int fd, short oldevent) 
    2829{ 
    29         return m_system.remove(fd, event); 
     30        return m_system.remove(fd, oldevent); 
    3031} 
    31 int event<void>::remove(int fd, short event) 
     32int event<void>::remove(int fd, short oldevent) 
    3233{ 
    33         return m_system.remove(fd, event); 
     34        return m_system.remove(fd, oldevent); 
     35} 
     36 
     37template <typename Data> 
     38int event<Data>::modify(int fd, short oldevent, short newevent) 
     39{ 
     40        return m_system.modify(fd, oldevent, newevent); 
     41} 
     42int event<void>::modify(int fd, short oldevent, short newevent) 
     43{ 
     44        return m_system.modify(fd, oldevent, newevent); 
    3445} 
    3546 

  • lang/c/mpio/trunk/mp/mempool.erb.h

    r6251 r6633  
    2929        template <size_t size> 
    3030                inline void* malloc(); 
     31public: 
     32        template <typename T> 
     33        inline void destroy(T* x) { 
     34                x->~T(); 
     35                this->free(x); 
     36        } 
     37<% def args(n, sep = "", &block) 
     38        Array.new(n) {|i| yield i+1 } .join(sep) 
     39end -%> 
     40<% (0..16).each do |n| -%> 
     41        template <typename T<%= args(n) {|i| ", typename A#{i}" } %>> 
     42        inline T* construct(<%= args(n, ", ") {|i| "A#{i} a#{i}" } %>) { 
     43                return new( this->malloc<sizeof(T)>() ) T(<%= args(n, ", ") {|i| "a#{i}" } %>); 
     44        } 
     45<% end -%> 
    3146private: 
    3247        struct chunk_t { 
    … …  
    4964private: 
    5065        mempool(const mempool&); 
    51 public: 
    52         template <typename T> 
    53         inline void destroy(T* x) { 
    54                 x->~T(); 
    55                 this->free(x); 
    56         } 
    57 <% 
    58 def args(n, sep = "", &block) 
    59         Array.new(n) {|i| yield i+1 } .join(sep) 
    60 end 
    61 -%> 
    62 <% (0..16).each do |n| -%> 
    63         template <typename T<%= args(n) {|i| ", typename A#{i}" } %>> 
    64         inline T* construct(<%= args(n, ", ") {|i| "A#{i} a#{i}" } %>) { 
    65                 return new( this->malloc<sizeof(T)>() ) T(<%= args(n, ", ") {|i| "a#{i}" } %>); 
    66         } 
    67 <% end -%> 
    6866}; 
    6967 

  • lang/c/mpio/trunk/mp/system/buffered_kqueue.h

    r6514 r6633  
    1313namespace mp { 
    1414 
    15  
    16 const static short EV_READ  = EVFILT_READ; 
    17 const static short EV_WRITE = EVFILT_WRITE; 
     15static const short EV_READ  = 0x01; 
     16static const short EV_WRITE = 0x02; 
    1817 
    1918class system { 
    … …  
    2120        system(); 
    2221        int add(int fd, short event); 
    23         int remove(int fd, short event); 
     22        int remove(int fd, short oldevent); 
     23        int modify(int fd, short oldevent, short newevent); 
    2424        int wait(void); 
    2525        int wait(int timeout_msec); 
    … …  
    3737private: 
    3838        int m_kqfd; 
     39        static const short EVFILT_MAP[3]; 
    3940}; 
    4041 

  • lang/c/mpio/trunk/mp/system/buffered_kqueue_impl.h

    r6514 r6633  
    44namespace mp { 
    55 
     6 
     7const short system::EVFILT_MAP[3] = {0, EVFILT_READ, EVFILT_WRITE}; 
    68 
    79system::system() 
    … …  
    1618{ 
    1719        struct kevent kev; 
    18         EV_SET(&kev, fd, event, EV_ADD, 0, 0, NULL); 
    19         m_buffered.push_back(kev); 
     20        if( event & EV_READ ) { 
     21                EV_SET(&kev, fd, EV_READ,  EV_ADD, 0, 0, NULL); 
     22                m_buffered.push_back(kev); 
     23        } 
     24        if( event & EV_WRITE ) { 
     25                EV_SET(&kev, fd, EV_WRITE, EV_ADD, 0, 0, NULL); 
     26                m_buffered.push_back(kev); 
     27        } 
    2028        return 0; 
    2129} 
    2230 
    23 int system::remove(int fd, short event) 
     31int system::remove(int fd, short oldevent) 
    2432{ 
    2533        struct kevent kev; 
    26         if( event & EV_READ ) { 
     34        if( oldevent & EV_READ ) { 
    2735                EV_SET(&kev, fd, EV_READ,  EV_DELETE, 0, 0, NULL); 
    2836                m_buffered.push_back(kev); 
    2937        } 
    30         if( event & EV_WRITE ) { 
     38        if( oldevent & EV_WRITE ) { 
    3139                EV_SET(&kev, fd, EV_WRITE, EV_DELETE, 0, 0, NULL); 
    3240                m_buffered.push_back(kev); 
    3341        } 
     42        return 0; 
     43} 
     44 
     45int system::modify(int fd, short oldevent, short newevent) 
     46{ 
     47        short add_event = ~oldevent & newevent; 
     48        struct kevent kev; 
     49        if( add_event ) { 
     50                EV_SET(&kev, fd, EVFILT_MAP[add_event], EV_ADD, 0, 0, NULL); 
     51        } else { 
     52                short delete_event = oldevent & ~newevent; 
     53                EV_SET(&kev, fd, EVFILT_MAP[delete_event], EV_DELETE, 0, 0, NULL); 
     54        } 
     55        m_buffered.push_back(kev); 
    3456        return 0; 
    3557} 

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

    r6514 r6633  
    1919        system(); 
    2020        int add(int fd, short event); 
    21         int remove(int fd, short event); 
     21        int remove(int fd, short oldevent); 
     22        int modify(int fd, short oldevent, short newevent); 
    2223        int wait(void); 
    2324        int wait(int timeout_msec); 
     25        bool next(int* rfd, short* revent); 
    2426private: 
    2527        struct backlog { 
    26                 backlog() {} 
    27                 bool next(int* rfd, short* revent); 
     28                backlog(); 
    2829                int count; 
    2930                int num; 

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

    r6514 r6633  
    2020} 
    2121 
    22 int system::remove(int fd, short event) 
     22int system::remove(int fd, short oldevent) 
    2323{ 
    2424        return epoll_ctl(m_epfd, EPOLL_CTL_DEL, fd, NULL); 
     25} 
     26 
     27int system::modify(int fd, short oldevent, short newevent) 
     28{ 
     29        struct epoll_event ep; 
     30        ep.events = newevent; 
     31        ep.data.fd = fd; 
     32        return epoll_ctl(m_epfd, EPOLL_CTL_MOD, fd, &ep); 
    2533} 
    2634 

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

    r6514 r6633  
    1212namespace mp { 
    1313 
    14  
    15 const static short EV_READ  = EVFILT_READ; 
    16 const static short EV_WRITE = EVFILT_WRITE; 
     14static const short EV_READ  = 0x01; 
     15static const short EV_WRITE = 0x02; 
    1716 
    1817class system { 
    … …  
    2019        system(); 
    2120        int add(int fd, short event); 
    22         int remove(int fd, short event); 
     21        int remove(int fd, short oldevent); 
     22        int modify(int fd, short oldevent, short newevent); 
    2323        int wait(void); 
    2424        int wait(int timeout_msec); 
    … …  
    3434private: 
    3535        int m_kqfd; 
     36        static const short EVFILT_MAP[3]; 
    3637}; 
    3738 

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

    r6514 r6633  
    44namespace mp { 
    55 
     6 
     7const short system::EVFILT_MAP[3] = {0, EVFILT_READ, EVFILT_WRITE}; 
    68 
    79system::system() 
    … …  
    1517int system::add(int fd, short event) 
    1618{ 
     19        if( event == EV_READ | EV_WRITE ) { 
     20                struct kevent kev[2]; 
     21                EV_SET(&kev[0], fd, EVFILT_READ,  EV_ADD, 0, 0, NULL); 
     22                EV_SET(&kev[1], fd, EVFILT_WRITE, EV_ADD, 0, 0, NULL); 
     23                return kevent(m_kqfd, kev, 2, NULL, 0, NULL); 
     24        } 
    1725        struct kevent kev; 
    18         EV_SET(&kev, fd, event, EV_ADD, 0, 0, NULL); 
     26        EV_SET(&kev, fd, EVFILT_MAP[event], EV_ADD, 0, 0, NULL); 
    1927        return kevent(m_kqfd, &kev, 1, NULL, 0, NULL); 
    2028} 
    2129 
    22 int system::remove(int fd, short event) 
     30int system::remove(int fd, short oldevent) 
    2331{ 
    24         if( event & EVFILT_READ && event & EVFILT_WRITE ) { 
     32        if( oldevent == EV_READ | EV_WRITE ) { 
    2533                struct kevent kev[2]; 
    2634                EV_SET(&kev[0], fd, EVFILT_READ,  EV_DELETE, 0, 0, NULL); 
    … …  
    2937        } 
    3038        struct kevent kev; 
    31         EV_SET(&kev, fd, event, EV_ADD, 0, 0, NULL); 
     39        EV_SET(&kev, fd, EVFILT_MAP[oldevent], EV_DELETE, 0, 0, NULL); 
     40        return kevent(m_kqfd, &kev, 1, NULL, 0, NULL); 
     41} 
     42 
     43int system::modify(int fd, short oldevent, short newevent) 
     44{ 
     45        short add_event = ~oldevent & newevent; 
     46        struct kevent kev; 
     47        if( add_event ) { 
     48                EV_SET(&kev, fd, EVFILT_MAP[add_event], EV_ADD, 0, 0, NULL); 
     49        } else { 
     50                short delete_event = oldevent & ~newevent; 
     51                EV_SET(&kev, fd, EVFILT_MAP[delete_event], EV_DELETE, 0, 0, NULL); 
     52        } 
    3253        return kevent(m_kqfd, &kev, 1, NULL, 0, NULL); 
    3354} 

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

    r6514 r6633  
    1616        system(); 
    1717        int add(int fd, short event); 
    18         int remove(int fd, short event); 
     18        int remove(int fd, short oldevent); 
     19        int modify(int fd, short oldevent, short newevent); 
    1920        int wait(void); 
    2021        int wait(int timeout_msec); 

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

    r6514 r6633  
    2525} 
    2626 
    27 int system::remove(int fd, short event) 
     27int system::remove(int fd, short oldevent) 
    2828{ 
    2929        // FIXME m_maxfdはどすうる？m_framework->size(); 
    3030        FD_CLR(fd, &m_readset); 
    3131        FD_CLR(fd, &m_writeset); 
     32        return 0; 
     33} 
     34 
     35int system::modify(int fd, short oldevent, short newevent) 
     36{ 
     37        FD_CLR(fd, &m_readset); 
     38        FD_CLR(fd, &m_writeset); 
     39        if( newevent & EV_READ ) { 
     40                FD_SET(fd, &m_readset); 
     41        } 
     42        if( newevent & EV_WRITE ) { 
     43                FD_SET(fd, &m_writeset); 
     44        } 
    3245        return 0; 
    3346}