Add thread::Timer for per process timers

Author: tyler-gilbert

libraries/ThreadAPI/include/CMakeLists.txt

@@ -7,6 +7,7 @@ set(SOURCES
 	thread/Mutex.hpp
 	thread/Signal.hpp
 	thread/Sched.hpp
+	thread/Timer.hpp
 	thread/Sem.hpp
 	PARENT_SCOPE
 	)

libraries/ThreadAPI/include/thread.hpp

@@ -12,6 +12,7 @@ namespace thread {}
 #include "thread/Sem.hpp"
 #include "thread/Signal.hpp"
 #include "thread/Thread.hpp"
+#include "thread/Timer.hpp"
 
 using namespace thread;
 

libraries/ThreadAPI/include/thread/Signal.hpp

@@ -46,7 +46,7 @@ union sigval {
 
 namespace thread {
 
-class SignalFlags {
+class SignalFlags : public api::ExecutionContext{
 public:
   enum class Number {
     null = 0,
@@ -88,7 +88,7 @@ class SignalFlags {
   };
 };
 
-class SignalHandler : public api::ExecutionContext, public SignalFlags {
+class SignalHandler : public SignalFlags {
 public:
   class Construct {
     API_AF(Construct, signal_function_callback_t, signal_function, nullptr);
@@ -105,26 +105,86 @@ class SignalHandler : public api::ExecutionContext, public SignalFlags {
       m_sig_action.sa_handler = (_sig_func_ptr)options.signal_function();
 #endif
       m_sig_action.sa_flags = 0;
-      m_sig_action.sa_mask = {0};
+      m_sig_action.sa_mask = {};
     } else {
       m_sig_action.sa_sigaction = options.signal_action();
       m_sig_action.sa_flags = options.flags() | SIGNAL_SIGINFO_FLAG;
       m_sig_action.sa_mask = options.mask();
     }
   }
 
+  explicit SignalHandler(signal_function_callback_t function){
+    m_sig_action.sa_handler = (_sig_func_ptr)function;
+  }
+
+  explicit SignalHandler(signal_action_callback_t action){
+    m_sig_action.sa_sigaction = action;
+    m_sig_action.sa_flags = SIGNAL_SIGINFO_FLAG;
+  }
+
   API_NO_DISCARD const struct sigaction *sigaction() const {
     return &m_sig_action;
   }
 
+  static SignalHandler default_(){
+    return SignalHandler(SignalHandler::Construct().set_signal_function((signal_function_callback_t)SIG_DFL));
+  }
+
+  static SignalHandler ignore(){
+    return SignalHandler(SignalHandler::Construct().set_signal_function((signal_function_callback_t)SIG_IGN));
+  }
+
 private:
-  struct sigaction m_sig_action;
+  struct sigaction m_sig_action = {};
 };
 
-class Signal : public api::ExecutionContext, public SignalFlags {
+class Signal : public SignalFlags {
 public:
 
 #if !defined __link
+  class Event {
+  public:
+    enum class Notify {
+        none = SIGEV_NONE,
+        signal = SIGEV_SIGNAL,
+        thread = SIGEV_THREAD
+    };
+
+    Event & set_notify(Notify value){
+      m_event.sigev_notify = int(value);
+      return *this;
+    }
+
+    Event & set_number(Number value){
+      m_event.sigev_signo = int(value);
+      return *this;
+    }
+
+    Event & set_value(int value){
+      m_event.sigev_value.sival_int = value;
+      return *this;
+    }
+
+    Event & set_value(void * value){
+      m_event.sigev_value.sival_ptr = value;
+      return *this;
+    }
+
+    Event & set_notify_function(void (*value)(sigval)){
+      m_event.sigev_notify_function = value;
+      return *this;
+    }
+
+    Event & set_notify_attributes(pthread_attr_t * value){
+      m_event.sigev_notify_attributes = value;
+      return *this;
+    }
+
+  private:
+    friend class Timer;
+    struct sigevent m_event = {};
+  };
+
   class Set {
   public:
     Set &add(Number signo) {
@@ -183,6 +243,7 @@ class Signal : public api::ExecutionContext, public SignalFlags {
   static Signal wait(const Set &set);
 #endif
 
+  Number number() const { return Number(m_signo); }
   API_NO_DISCARD int signo() const { return m_signo; }
   API_NO_DISCARD int sigvalue() const { return m_sigvalue.sival_int; }
   API_NO_DISCARD void *sigptr() const { return m_sigvalue.sival_ptr; }

libraries/ThreadAPI/include/thread/Timer.hpp

@@ -0,0 +1,63 @@
+// Copyright 2011-2021 Tyler Gilbert and Stratify Labs, Inc; see LICENSE.md
+
+#ifndef THREADAPI_THREAD_TIMER_HPP
+#define THREADAPI_THREAD_TIMER_HPP
+
+#include <signal.h>
+
+#include "chrono/ClockTime.hpp"
+#include "Signal.hpp"
+
+namespace thread {
+
+class Timer : public api::ExecutionContext {
+public:
+  using ClockId = chrono::ClockTime::ClockId;
+  Timer(Signal::Event& signal_event, ClockId clock_id = ClockId::realtime);
+  ~Timer();
+
+  Timer(const Timer & a) = delete;
+  Timer& operator=(const Timer &a) = delete;
+
+  Timer(Timer && a){
+    std::swap(m_timer, a.m_timer);
+  }
+
+  Timer& operator=(Timer &&a){
+    std::swap(m_timer, a.m_timer);
+    return *this;
+  }
+
+  bool is_valid() const {
+    return m_timer != timer_t(-1);
+  }
+
+  enum class Flags {
+    null = 0,
+    absolute_time = TIMER_ABSTIME
+  };
+
+  class SetTime {
+    API_AC(SetTime, chrono::ClockTime, interval);
+    API_AC(SetTime, chrono::ClockTime, value);
+    API_AF(SetTime, Flags, flags, Flags::null);
+  };
+
+  Timer & set_time(const SetTime & options);
+
+  class Info {
+    API_RAC(Info, chrono::ClockTime, interval);
+    API_RAC(Info, chrono::ClockTime, value);
+    friend class Timer;
+  };
+
+  Info get_info() const;
+
+private:
+  timer_t m_timer = timer_t(-1);
+
+};
+
+} // namespace thread
+
+#endif // THREADAPI_THREAD_TIMER_HPP

libraries/ThreadAPI/src/CMakeLists.txt

@@ -7,5 +7,6 @@ set(SOURCES
 	Sem.cpp
 	Mq.cpp
 	Sched.cpp
+	Timer.cpp
 	PARENT_SCOPE
 	)

libraries/ThreadAPI/src/Timer.cpp

@@ -0,0 +1,39 @@
+#include "thread/Timer.hpp"
+
+using namespace thread;
+
+Timer::Timer(Signal::Event &signal_event, ClockId clock_id) {
+  API_RETURN_IF_ERROR();
+  API_SYSTEM_CALL(
+      "", timer_create(clockid_t(clock_id), &signal_event.m_event, &m_timer));
+}
+
+Timer::~Timer() {
+  if (is_valid()) {
+    timer_delete(m_timer);
+  }
+}
+
+Timer &Timer::set_time(const SetTime &options) {
+  API_RETURN_VALUE_IF_ERROR(*this);
+  API_ASSERT(is_valid());
+
+  struct itimerspec value = {.it_interval = *options.interval().timespec(),
+                             .it_value = *options.value().timespec()};
+
+  API_SYSTEM_CALL("", timer_settime(m_timer, int(options.flags()), &value, nullptr));
+  return *this;
+}
+
+
+Timer::Info Timer::get_info() const {
+  API_RETURN_VALUE_IF_ERROR(Info());
+
+  Info result;
+  struct itimerspec value;
+  API_SYSTEM_CALL("", timer_gettime(m_timer, &value));
+  result.m_interval = value.it_interval;
+  result.m_value = value.it_value;
+  return result;
+}
+