loop.hh

Go to the documentation of this file.

 // This Source Code Form is licensed MPL-2.0: http://mozilla.org/MPL/2.0
#ifndef __ASE_LOOP_HH__
#define __ASE_LOOP_HH__
 
#include <ase/utils.hh>
 
namespace Ase {
 
// === PollFD ===
struct PollFD   
{
  int           fd;
  uint16        events;
  uint16        revents;
  enum : uint {
    IN          = ASE_SYSVAL_POLLINIT[0],  
    PRI         = ASE_SYSVAL_POLLINIT[1],  
    OUT         = ASE_SYSVAL_POLLINIT[2],  
    RDNORM      = ASE_SYSVAL_POLLINIT[3],  
    RDBAND      = ASE_SYSVAL_POLLINIT[4],  
    WRNORM      = ASE_SYSVAL_POLLINIT[5],  
    WRBAND      = ASE_SYSVAL_POLLINIT[6],  
    // Event types unconditionally updated in .revents
    ERR         = ASE_SYSVAL_POLLINIT[7],  
    HUP         = ASE_SYSVAL_POLLINIT[8],  
    NVAL        = ASE_SYSVAL_POLLINIT[9],  
  };
};
 
// === Prototypes ===
class EventSource;
typedef std::shared_ptr<EventSource> EventSourceP;
class TimedSource;
typedef std::shared_ptr<TimedSource> TimedSourceP;
class PollFDSource;
typedef std::shared_ptr<PollFDSource> PollFDSourceP;
class DispatcherSource;
typedef std::shared_ptr<DispatcherSource> DispatcherSourceP;
class USignalSource;
typedef std::shared_ptr<USignalSource> USignalSourceP;
class SigchldSource;
typedef std::shared_ptr<SigchldSource> SigchldSourceP;
class EventLoop;
typedef std::shared_ptr<EventLoop> EventLoopP;
class MainLoop;
typedef std::shared_ptr<MainLoop> MainLoopP;
struct LoopState;
#if     defined __G_LIB_H__ || defined DOXYGEN
typedef ::GMainContext GlibGMainContext;
#else
struct GlibGMainContext; // dummy type
#endif
 
// === EventLoop ===
class EventLoop : public virtual std::enable_shared_from_this<EventLoop>
{
  struct QuickPfdArray;         // pseudo vector<PollFD>
  friend class MainLoop;
protected:
  typedef std::vector<EventSourceP> SourceList;
  MainLoop     *main_loop_;
  SourceList    sources_;
  std::vector<EventSourceP> poll_sources_;
  int16         dispatch_priority_;
  bool          primary_;
  explicit      EventLoop           (MainLoop&);
  virtual      ~EventLoop           ();
  EventSourceP& find_first_L        ();
  EventSourceP& find_source_L       (uint id);
  bool          has_primary_L       (void);
  void          remove_source_Lm    (EventSourceP source);
  void          kill_sources_Lm     (void);
  void          unpoll_sources_U    ();
  void          collect_sources_Lm  (LoopState&);
  bool          prepare_sources_Lm  (LoopState&, QuickPfdArray&);
  bool          check_sources_Lm    (LoopState&, const QuickPfdArray&);
  void          dispatch_source_Lm  (LoopState&);
public:
  typedef std::function<void (void)>             VoidSlot;
  typedef std::function<bool (void)>             BoolSlot;
  typedef std::function<void (PollFD&)>          VPfdSlot;
  typedef std::function<bool (PollFD&)>          BPfdSlot;
  typedef std::function<bool (const LoopState&)> DispatcherSlot;
  typedef std::function<bool (int8)>             USignalSlot;
  typedef std::function<void (int,int)>          SigchldSlot;
  static const int16 PRIORITY_CEILING = 999; 
  static const int16 PRIORITY_NOW     = 900; 
  static const int16 PRIORITY_ASCENT  = 800; 
  static const int16 PRIORITY_HIGH    = 700; 
  static const int16 PRIORITY_NEXT    = 600; 
  static const int16 PRIORITY_NORMAL  = 500; 
  static const int16 PRIORITY_UPDATE  = 400; 
  static const int16 PRIORITY_IDLE    = 200; 
  static const int16 PRIORITY_LOW     = 100; 
  void wakeup   ();                          
  // source handling
  uint add             (EventSourceP loop_source, int priority
                        = PRIORITY_NORMAL);     
  void remove          (uint            id);    
  void remove          (uint           *idp);   
  bool try_remove      (uint            id);    
  bool clear_source    (uint *id_pointer);      
  void destroy_loop    (void);
  bool has_primary     (void);                  
  bool flag_primary    (bool            on);
  MainLoop* main_loop  () const;                
  template<class BoolVoidFunctor>
  uint exec_now        (BoolVoidFunctor &&bvf); 
  template<class BoolVoidFunctor>
  uint exec_callback   (BoolVoidFunctor &&bvf, int priority
                        = PRIORITY_NORMAL);     
  template<class BoolVoidFunctor>
  uint exec_idle       (BoolVoidFunctor &&bvf); 
  uint exec_dispatcher (const DispatcherSlot &sl, int priority
                        = PRIORITY_NORMAL);     
  uint exec_usignal    (int8 signum, const USignalSlot &sl, int priority
                        = PRIORITY_NOW -1);     
  uint exec_sigchld    (int64_t pid, const SigchldSlot &vfunc, int priority
                        = PRIORITY_NORMAL);     
  bool exec_once       (uint delay_ms, uint *once_id, const VoidSlot &vfunc, int priority
                        = PRIORITY_NORMAL);     
  template<class BoolVoidFunctor>
  uint exec_timer      (BoolVoidFunctor &&bvf, uint delay_ms, int64 repeat_ms = -1, int priority = PRIORITY_NORMAL);
  template<class BoolVoidPollFunctor>
  uint exec_io_handler (BoolVoidPollFunctor &&bvf, int fd, const String &mode, int priority = PRIORITY_NORMAL);
};
 
// === MainLoop ===
class MainLoop : public EventLoop
{
  friend                class EventLoop;
  friend                class SubLoop;
  std::mutex            mutex_;
  uint                  rr_index_;
  std::vector<EventLoopP> loops_;
  EventFd               eventfd_;
  int8                  running_;
  int8                  has_quit_;
  int16                 quit_code_;
  GlibGMainContext     *gcontext_;
  bool                  finishable_L        ();
  void                  wakeup_poll         ();                 
  void                  add_loop_L          (EventLoop &loop);  
  void                  kill_loop_Lm        (EventLoop &loop);  
  void                  kill_loops_Lm       ();                 
  bool                  iterate_loops_Lm    (LoopState&, bool b, bool d);
  explicit              MainLoop            ();
  virtual              ~MainLoop            ();
  ASE_DEFINE_MAKE_SHARED (MainLoop);
public:
  int        run             (); 
  bool       running         (); 
  bool       finishable      (); 
  void       quit            (int quit_code = 0);    
  bool       pending         ();                     
  bool       iterate         (bool block);           
  void       iterate_pending (); 
  EventLoopP create_sub_loop (); 
  inline std::mutex& mutex   () { return mutex_; } 
  static MainLoopP   create  (); 
  bool    set_g_main_context (GlibGMainContext *glib_main_context); 
};
 
// === LoopState ===
struct LoopState {
  enum     Phase { NONE, COLLECT, PREPARE, CHECK, DISPATCH, DESTROY };
  Phase    phase = NONE;
  bool     seen_primary = false;   
  uint64   current_time_usecs = 0; 
  int64    timeout_usecs = 0;      
};
 
// === EventSource ===
class EventSource 
{
  friend       class EventLoop;
  ASE_CLASS_NON_COPYABLE (EventSource);
protected:
  EventLoop   *loop_;
  struct {
    PollFD    *pfd;
    uint       idx;
  }           *pfds_;
  uint         id_;
  int16        priority_;
  uint8        loop_state_;
  uint         may_recurse_ : 1;
  uint         dispatching_ : 1;
  uint         was_dispatching_ : 1;
  uint         primary_ : 1;
  uint         n_pfds      ();
  explicit     EventSource ();
  uint         source_id   () { return loop_ ? id_ : 0; }
  virtual     ~EventSource ();
public:
  virtual bool prepare     (const LoopState &state,
                            int64 *timeout_usecs_p) = 0;    
  virtual bool check       (const LoopState &state) = 0;    
  virtual bool dispatch    (const LoopState &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 loop_ ? loop_->main_loop() : NULL; } 
};
 
// === DispatcherSource ===
class DispatcherSource : public virtual EventSource 
{
  typedef EventLoop::DispatcherSlot DispatcherSlot;
  DispatcherSlot slot_;
  ASE_DEFINE_MAKE_SHARED (DispatcherSource);
protected:
  virtual     ~DispatcherSource ();
  virtual bool prepare          (const LoopState &state, int64 *timeout_usecs_p);
  virtual bool check            (const LoopState &state);
  virtual bool dispatch         (const LoopState &state);
  virtual void destroy          ();
  explicit     DispatcherSource (const DispatcherSlot &slot);
public:
  static DispatcherSourceP create (const DispatcherSlot &slot)
  { return make_shared (slot); }
};
 
// === USignalSource ===
class USignalSource : public virtual EventSource 
{
  typedef EventLoop::USignalSlot USignalSlot;
  USignalSlot slot_;
  int8        signum_ = 0, index_ = 0, shift_ = 0;
  ASE_DEFINE_MAKE_SHARED (USignalSource);
protected:
  virtual     ~USignalSource  ();
  virtual bool prepare        (const LoopState &state, int64 *timeout_usecs_p);
  virtual bool check          (const LoopState &state);
  virtual bool dispatch       (const LoopState &state);
  virtual void destroy        ();
  explicit     USignalSource  (int8 signum, const USignalSlot &slot);
public:
  static void           raise  (int8 signum);
  static USignalSourceP create (int8 signum, const USignalSlot &slot)
  { return make_shared (signum, slot); }
  static void install_sigaction (int8);
};
 
// === SigchldSource ===
class SigchldSource : public virtual EventSource 
{
  ASE_DEFINE_MAKE_SHARED (SigchldSource);
  typedef EventLoop::SigchldSlot SigchldSlot;
  SigchldSlot slot_;
  uint64_t    sigchld_counter_ = 0;
  int64_t     pid_ = 0;
protected:
  virtual     ~SigchldSource   ();
  virtual bool prepare         (const LoopState &state, int64 *timeout_usecs_p);
  virtual bool check           (const LoopState &state);
  virtual bool dispatch        (const LoopState &state);
  virtual void destroy         ();
  explicit     SigchldSource   (int64_t pid, const SigchldSlot &slot);
public:
  static SigchldSourceP create (int64_t pid, const SigchldSlot &slot)
  { return make_shared (pid, slot); }
};
 
// === TimedSource ===
class TimedSource : public virtual EventSource 
{
  typedef EventLoop::BoolSlot BoolSlot;
  typedef EventLoop::VoidSlot VoidSlot;
  uint64     expiration_usecs_;
  uint       interval_msecs_;
  bool       first_interval_;
  const bool oneshot_;
  union {
    BoolSlot bool_slot_;
    VoidSlot void_slot_;
  };
  ASE_DEFINE_MAKE_SHARED (TimedSource);
protected:
  virtual     ~TimedSource  ();
  virtual bool prepare      (const LoopState &state, int64 *timeout_usecs_p);
  virtual bool check        (const LoopState &state);
  virtual bool dispatch     (const LoopState &state);
  explicit     TimedSource  (const BoolSlot &slot, uint initial_interval_msecs, uint repeat_interval_msecs);
  explicit     TimedSource  (const VoidSlot &slot, uint initial_interval_msecs, uint repeat_interval_msecs);
public:
  static TimedSourceP create (const BoolSlot &slot, uint initial_interval_msecs = 0, uint repeat_interval_msecs = 0)
  { return make_shared (slot, initial_interval_msecs, repeat_interval_msecs); }
  static TimedSourceP create (const VoidSlot &slot, uint initial_interval_msecs = 0, uint repeat_interval_msecs = 0)
  { return make_shared (slot, initial_interval_msecs, repeat_interval_msecs); }
};
 
// === PollFDSource ===
class PollFDSource : public virtual EventSource 
{
  typedef EventLoop::BPfdSlot BPfdSlot;
  typedef EventLoop::VPfdSlot VPfdSlot;
protected:
  void          construct       (const String &mode);
  virtual      ~PollFDSource    ();
  virtual bool  prepare         (const LoopState &state, int64 *timeout_usecs_p);
  virtual bool  check           (const LoopState &state);
  virtual bool  dispatch        (const LoopState &state);
  virtual void  destroy         ();
  PollFD        pfd_;
  uint          never_close_ : 1;      // 'C'
private:
  const uint    oneshot_ : 1;
  union {
    BPfdSlot bool_poll_slot_;
    VPfdSlot void_poll_slot_;
  };
  explicit      PollFDSource    (const BPfdSlot &slot, int fd, const String &mode);
  explicit      PollFDSource    (const VPfdSlot &slot, int fd, const String &mode);
  ASE_DEFINE_MAKE_SHARED (PollFDSource);
public:
  static PollFDSourceP create (const BPfdSlot &slot, int fd, const String &mode)
  { return make_shared (slot, fd, mode); }
  static PollFDSourceP create (const VPfdSlot &slot, int fd, const String &mode)
  { return make_shared (slot, fd, mode); }
};
 
// === EventLoop methods ===
template<class BoolVoidFunctor> uint
EventLoop::exec_now (BoolVoidFunctor &&bvf)
{
  typedef decltype (bvf()) ReturnType;
  std::function<ReturnType()> slot (bvf);
  TimedSourceP tsource = TimedSource::create (slot);
  tsource->primary (true);
  return add (tsource, PRIORITY_NOW);
}
 
template<class BoolVoidFunctor> uint
EventLoop::exec_callback (BoolVoidFunctor &&bvf, int priority)
{
  typedef decltype (bvf()) ReturnType;
  std::function<ReturnType()> slot (bvf);
  return add (TimedSource::create (slot), priority);
}
 
template<class BoolVoidFunctor> uint
EventLoop::exec_idle (BoolVoidFunctor &&bvf)
{
  typedef decltype (bvf()) ReturnType;
  std::function<ReturnType()> slot (bvf);
  return add (TimedSource::create (slot), PRIORITY_IDLE);
}
 
inline uint
EventLoop::exec_dispatcher (const DispatcherSlot &slot, int priority)
{
  return add (DispatcherSource::create (slot), priority);
}
 
inline uint
EventLoop::exec_usignal (int8 signum, const USignalSlot &slot, int priority)
{
  return add (USignalSource::create (signum, slot), priority);
}
 
inline uint
EventLoop::exec_sigchld (int64_t pid, const SigchldSlot &slot, int priority)
{
  return add (SigchldSource::create (pid, slot), priority);
}
 
template<class BoolVoidFunctor> uint
EventLoop::exec_timer (BoolVoidFunctor &&bvf, uint delay_ms, int64 repeat_ms, int priority)
{
  typedef decltype (bvf()) ReturnType;
  std::function<ReturnType()> slot (bvf);
  return add (TimedSource::create (slot, delay_ms, repeat_ms < 0 ? delay_ms : repeat_ms), priority);
}
 
template<class BoolVoidPollFunctor> uint
EventLoop::exec_io_handler (BoolVoidPollFunctor &&bvf, int fd, const String &mode, int priority)
{
  using ReturnType = decltype (bvf (*std::declval<PollFD*>()));
  std::function<ReturnType (PollFD&)> slot (bvf);
  return add (PollFDSource::create (slot, fd, mode), priority);
}
 
} // Ase
 
#endif  /* __ASE_LOOP_HH__ */