loop.hh

Go to the documentation of this file.

// Licensed GNU LGPL v3 or later: http://www.gnu.org/licenses/lgpl.html
#ifndef __RAPICORN_LOOP_HH__
#define __RAPICORN_LOOP_HH__

#include <rcore/utilities.hh>
#include <rcore/rapicornthread.hh>
#include <rcore/rapicornsignal.hh>


namespace Rapicorn {

// === PollFD ===
struct PollFD   
{
  int           fd;
  uint16        events;
  uint16        revents;
  enum {
    IN          = RAPICORN_SYSVAL_POLLIN,       
    PRI         = RAPICORN_SYSVAL_POLLPRI,      
    OUT         = RAPICORN_SYSVAL_POLLOUT,      
    RDNORM      = RAPICORN_SYSVAL_POLLRDNORM,   
    RDBAND      = RAPICORN_SYSVAL_POLLRDBAND,   
    WRNORM      = RAPICORN_SYSVAL_POLLWRNORM,   
    WRBAND      = RAPICORN_SYSVAL_POLLWRBAND,   
    /* Event types updated in .revents regardlessly */
    ERR         = RAPICORN_SYSVAL_POLLERR,      
    HUP         = RAPICORN_SYSVAL_POLLHUP,      
    NVAL        = RAPICORN_SYSVAL_POLLNVAL,     
  };
};

// === EventFd ===
class EventFd   
{
  int      fds[2];
public:
  explicit EventFd   ();
  int      open      (); 
  bool     opened    (); 
  void     wakeup    (); 
  int      inputfd   (); 
  bool     pollin    (); 
  void     flush     (); 
  /*Des*/ ~EventFd   ();
};

// === EventLoop ===
class MainLoop;
class EventLoop : public virtual BaseObject 
{
  class TimedSource;
  class PollFDSource;
  friend           class MainLoop;
public:
  class Source;
  class State;
protected:
  typedef std::vector<Source*>    SourceList;
  MainLoop     &m_main_loop;
  SourceList    m_sources;
  int64         m_dispatch_priority;
  SourceList    m_poll_sources;
  explicit      EventLoop        (MainLoop&);
  virtual      ~EventLoop        ();
  Source*       find_first_L     ();
  Source*       find_source_L    (uint id);
  bool          has_primary_L    (void);
  void          remove_source_Lm (Source *source);
  void          kill_sources_Lm  (void);
  void          unpoll_sources_U    ();
  void          collect_sources_Lm  (State&);
  bool          prepare_sources_Lm  (State&, int64*, vector<PollFD>&);
  bool          check_sources_Lm    (State&, const vector<PollFD>&);
  Source*       dispatch_source_Lm  (State&);
  typedef Signals::Slot1<void,PollFD&> VPfdSlot;
  typedef Signals::Slot1<bool,PollFD&> BPfdSlot;
public:
  static const int PRIORITY_NOW        = -1073741824;   
  static const int PRIORITY_HIGH       = -100 - 10;     
  static const int PRIORITY_NEXT       = -100 - 5;      
  static const int PRIORITY_NOTIFY     =    0 - 1;      
  static const int PRIORITY_NORMAL     =    0;          
  static const int PRIORITY_UPDATE     = +100 + 5;      
  static const int PRIORITY_IDLE       = +200;          
  static const int PRIORITY_BACKGROUND = +300 + 500;    
  void wakeup   ();                                     
  // source handling
  uint add      (Source *loop_source,
                 int priority = PRIORITY_IDLE); 
  void remove          (uint            id);    
  bool try_remove      (uint            id);    
  void kill_sources    (void);                  
  bool has_primary     (void);                  
  uint exec_now        (const VoidSlot &sl);    
  uint exec_now        (const BoolSlot &sl);    
  uint exec_next       (const VoidSlot &sl);    
  uint exec_next       (const BoolSlot &sl);    
  uint exec_notify     (const VoidSlot &sl);    
  uint exec_notify     (const BoolSlot &sl);    
  uint exec_normal     (const VoidSlot &sl);    
  uint exec_normal     (const BoolSlot &sl);    
  uint exec_update     (const VoidSlot &sl);    
  uint exec_update     (const BoolSlot &sl);    
  uint exec_background (const VoidSlot &sl);    
  uint exec_background (const BoolSlot &sl);    
  uint exec_timer      (uint            timeout_ms,
                        const VoidSlot &sl,
                        int             priority = PRIORITY_NEXT); 
  uint exec_timer      (uint            initial_timeout_ms,
                        uint            repeat_timeout_ms,
                        const BoolSlot &sl,
                        int             priority = PRIORITY_NEXT); 
  uint exec_io_handler (const VPfdSlot &sl,
                        int             fd,
                        const String   &mode,
                        int             priority = PRIORITY_NORMAL); 
  uint exec_io_handler (const BPfdSlot &sl,
                        int             fd,
                        const String   &mode,
                        int             priority = PRIORITY_NORMAL); 
  MainLoop* main_loop  () const { return &m_main_loop; } 
};

// === MainLoop ===
class MainLoop : public EventLoop 
{
  friend                class EventLoop;
  friend                class SlaveLoop;
  Mutex                 m_mutex;
  vector<EventLoop*>    m_loops;
  EventFd               m_eventfd;
  uint                  m_rr_index;
  bool                  m_running;
  int                   m_quit_code;
  bool                  finishable_L        ();
  void                  wakeup_poll         ();                 
  void                  add_loop_L          (EventLoop &loop);  
  void                  remove_loop_L       (EventLoop &loop);  
  bool                  iterate_loops_Lm    (State&, bool b, bool d);
  explicit              MainLoop            ();
public:
  virtual   ~MainLoop        ();
  int        run             (); 
  void       quit            (int quit_code = 0); 
  bool       finishable      (); 
  bool       iterate         (bool block); 
  void       iterate_pending (); 
  void       kill_loops      (); 
  EventLoop* new_slave       (); 
  static MainLoop*  _new     (); 
  inline Mutex&     mutex    () { return m_mutex; } 

  struct LockHooks { bool (*sense) (); void (*lock) (); void (*unlock) (); };
  void              set_lock_hooks      (const LockHooks &hooks);
private: LockHooks  m_lock_hooks;
};

// === EventLoop::State ===
struct EventLoop::State {
  uint64 current_time_usecs;
  bool   seen_primary; 
  State();
};

// === EventLoop::Source ===
class EventLoop::Source : public virtual ReferenceCountable, protected NonCopyable 
{
  friend        class EventLoop;
protected:
  EventLoop   *m_loop;
  struct {
    PollFD    *pfd;
    uint       idx;
  }           *m_pfds;
  uint         m_id;
  int          m_priority;
  uint16       m_loop_state;
  uint         m_may_recurse : 1;
  uint         m_dispatching : 1;
  uint         m_was_dispatching : 1;
  uint         m_primary : 1;
  uint         n_pfds      ();
  explicit     Source      ();
  uint         source_id   () { return m_loop ? m_id : 0; }
public:
  virtual     ~Source      ();
  virtual bool prepare     (const State &state,
                            int64 *timeout_usecs_p) = 0;    
  virtual bool check       (const State &state) = 0;        
  virtual bool dispatch    (const State &state) = 0;        
  virtual void destroy     ();
  bool         recursion   () const;                        
  bool         may_recurse () const;                        
  void         may_recurse (bool           may_recurse);    
  bool         primary     () const;                        
  void         primary     (bool           is_primary);     
  void         add_poll    (PollFD * const pfd);            
  void         remove_poll (PollFD * const pfd);            
  void         loop_remove ();                              
  MainLoop*    main_loop   () const { return m_loop ? m_loop->main_loop() : NULL; } 
};

// === EventLoop::TimedSource ===
class EventLoop::TimedSource : public virtual EventLoop::Source 
{
  uint64     m_expiration_usecs;
  uint       m_interval_msecs;
  bool       m_first_interval;
  const bool m_oneshot;
  union {
    Signals::Trampoline0<bool> *m_btrampoline;
    Signals::Trampoline0<void> *m_vtrampoline;
  };
protected:
  virtual     ~TimedSource  ();
  virtual bool prepare      (const State &state,
                             int64 *timeout_usecs_p);
  virtual bool check        (const State &state);
  virtual bool dispatch     (const State &state);
public:
  explicit     TimedSource (Signals::Trampoline0<bool> &bt,
                            uint initial_interval_msecs = 0,
                            uint repeat_interval_msecs = 0);
  explicit     TimedSource (Signals::Trampoline0<void> &vt,
                            uint initial_interval_msecs = 0,
                            uint repeat_interval_msecs = 0);
};

// === EventLoop::PollFDSource ===
class EventLoop::PollFDSource : public virtual EventLoop::Source 
{
protected:
  void          construct       (const String &mode);
  virtual      ~PollFDSource    ();
  virtual bool  prepare         (const State &state,
                                 int64 *timeout_usecs_p);
  virtual bool  check           (const State &state);
  virtual bool  dispatch        (const State &state);
  virtual void  destroy         ();
  PollFD        m_pfd;
  uint          m_ignore_errors : 1;    // 'E'
  uint          m_ignore_hangup : 1;    // 'H'
  uint          m_never_close : 1;      // 'C'
private:
  const uint    m_oneshot : 1;
  union {
    Signals::Trampoline1<bool,PollFD&> *m_btrampoline;
    Signals::Trampoline1<void,PollFD&> *m_vtrampoline;
  };
public:
  explicit      PollFDSource    (Signals::Trampoline1<bool,PollFD&> &bt,
                                 int                                 fd,
                                 const String                       &mode);
  explicit      PollFDSource    (Signals::Trampoline1<void,PollFD&> &vt,
                                 int                                 fd,
                                 const String                       &mode);
};

// === EventLoop methods ===
inline uint
EventLoop::exec_now (const VoidSlot &sl)
{
  return add (new TimedSource (*sl.get_trampoline()), PRIORITY_NOW);
}

inline uint
EventLoop::exec_now (const BoolSlot &sl)
{
  return add (new TimedSource (*sl.get_trampoline()), PRIORITY_NOW);
}

inline uint
EventLoop::exec_next (const VoidSlot &sl)
{
  return add (new TimedSource (*sl.get_trampoline()), PRIORITY_NEXT);
}

inline uint
EventLoop::exec_next (const BoolSlot &sl)
{
  return add (new TimedSource (*sl.get_trampoline()), PRIORITY_NEXT);
}

inline uint
EventLoop::exec_notify (const VoidSlot &sl)
{
  return add (new TimedSource (*sl.get_trampoline()), PRIORITY_NOTIFY);
}

inline uint
EventLoop::exec_notify (const BoolSlot &sl)
{
  return add (new TimedSource (*sl.get_trampoline()), PRIORITY_NOTIFY);
}

inline uint
EventLoop::exec_normal (const VoidSlot &sl)
{
  return add (new TimedSource (*sl.get_trampoline()), PRIORITY_NORMAL);
}

inline uint
EventLoop::exec_normal (const BoolSlot &sl)
{
  return add (new TimedSource (*sl.get_trampoline()), PRIORITY_NORMAL);
}

inline uint
EventLoop::exec_update (const VoidSlot &sl)
{
  return add (new TimedSource (*sl.get_trampoline()), PRIORITY_UPDATE);
}

inline uint
EventLoop::exec_update (const BoolSlot &sl)
{
  return add (new TimedSource (*sl.get_trampoline()), PRIORITY_UPDATE);
}

inline uint
EventLoop::exec_background (const VoidSlot &sl)
{
  return add (new TimedSource (*sl.get_trampoline()), PRIORITY_BACKGROUND);
}

inline uint
EventLoop::exec_background (const BoolSlot &sl)
{
  return add (new TimedSource (*sl.get_trampoline()), PRIORITY_BACKGROUND);
}

inline uint
EventLoop::exec_timer (uint            timeout_ms,
                       const VoidSlot &sl,
                       int             priority)
{
  return add (new TimedSource (*sl.get_trampoline(), timeout_ms, timeout_ms), priority);
}

inline uint
EventLoop::exec_timer (uint            initial_timeout_ms,
                       uint            repeat_timeout_ms,
                       const BoolSlot &sl,
                       int             priority)
{
  return add (new TimedSource (*sl.get_trampoline(), initial_timeout_ms, repeat_timeout_ms), priority);
}

inline uint
EventLoop::exec_io_handler (const VPfdSlot &sl,
                            int             fd,
                            const String   &mode,
                            int             priority)
{
  return add (new PollFDSource (*sl.get_trampoline(), fd, mode), priority);
}

inline uint
EventLoop::exec_io_handler (const BPfdSlot &sl,
                            int             fd,
                            const String   &mode,
                            int             priority)
{
  return add (new PollFDSource (*sl.get_trampoline(), fd, mode), priority);
}

} // Rapicorn

#endif  /* __RAPICORN_LOOP_HH__ */