ProtoThread.hh

Go to the documentation of this file.

#ifndef COSA_PROTO_THREAD_HH
#define COSA_PROTO_THREAD_HH

#include "Cosa/Job.hh"
#include "Cosa/Event.hh"

class ProtoThread : public Job {
public:
  enum {
    INITIATED = 0,              
    READY,                      
    WAITING,                    
    TIMEOUT,                    
    RUNNING,                    
    SLEEPING,                   
    TERMINATED = 0xff,          
  } __attribute__((packed));

  ProtoThread(Job::Scheduler* scheduler) :
    Job(scheduler),
    m_state(INITIATED),
    m_ip(0)
  {}

  bool begin()
  {
    if (UNLIKELY(m_state != INITIATED)) return (false);
    schedule(this);
    return (true);
  }

  void end()
  {
    m_state = TERMINATED;
    detach();
  }

  uint8_t state() const
  {
    return (m_state);
  }

  void set_timer(uint16_t ms)
    __attribute__((always_inline))
  {
    m_state = WAITING;
    detach();
    expire_after(ms);
    start();
  }

  void cancel_timer()
    __attribute__((always_inline))
  {
    detach();
  }

  bool timer_expired() const
    __attribute__((always_inline))
  {
    return (m_state == TIMEOUT);
  }

  virtual void on_run(uint8_t type, uint16_t value) = 0;

  static uint16_t dispatch(bool flag = true);

  static void schedule(ProtoThread* thread);

protected:
  static Head runq;
  uint8_t m_state;
  void* m_ip;

  virtual void on_event(uint8_t type, uint16_t value);
};

#define PROTO_THREAD_BEGIN()                            \
  if (m_ip != 0) goto *m_ip

#define PROTO_THREAD_YIELD()                            \
  do {                                                  \
    __label__ next;                                     \
    m_ip = &&next;                                      \
    return;                                             \
  next: ;                                               \
  } while (0)

#define PROTO_THREAD_SLEEP()                            \
  do {                                                  \
    m_state = SLEEPING;                                 \
    detach();                                           \
    PROTO_THREAD_YIELD();                               \
  } while (0)

#define PROTO_THREAD_WAKE(thread)                       \
  do {                                                  \
    if (thread->m_state == SLEEPING)                    \
      Thread::schedule(thread);                         \
  } while (0)

#define PROTO_THREAD_AWAIT(condition)                   \
  do {                                                  \
    __label__ next;                                     \
  next:                                                 \
    if (!(condition)) {                                 \
      m_ip = &&next;                                    \
      return;                                           \
    }                                                   \
  } while (0)

#define PROTO_THREAD_DELAY(ms)                          \
  do {                                                  \
    set_timer(ms);                                      \
    PROTO_THREAD_AWAIT(timer_expired());                \
  } while (0)

#define PROTO_THREAD_END()                              \
  do {                                                  \
    ProtoThread::end();                                 \
    return;                                             \
  } while (0)

#endif