implement a crude way to stop program on CTRL-C or EOF

include/iq_stream_decoder.hpp

@@ -16,6 +16,7 @@
 #include <bit_stream_decoder.hpp>
 #include <fixed_queue.hpp>
 #include <l2/lower_mac.hpp>
+#include <signal_handler.hpp>
 #include <streaming_ordered_output_thread_pool_executor.hpp>
 
 /**
@@ -27,7 +28,7 @@ class IQStreamDecoder {
   public:
     IQStreamDecoder(std::shared_ptr<LowerMac> lower_mac, std::shared_ptr<BitStreamDecoder> bit_stream_decoder,
                     bool is_uplink);
-    ~IQStreamDecoder() = default;
+    ~IQStreamDecoder();
 
     void process_complex(std::complex<float> symbol) noexcept;
 

include/signal_handler.hpp

@@ -0,0 +1,3 @@
+#pragma once
+
+volatile extern bool stop;

include/streaming_ordered_output_thread_pool_executor.hpp

@@ -18,12 +18,14 @@
 #include <type_traits>
 #include <vector>
 
+#include <signal_handler.hpp>
+
 // thread pool executing work but outputting it the order of the input
 template <typename ReturnType> class StreamingOrderedOutputThreadPoolExecutor {
 
   public:
     StreamingOrderedOutputThreadPoolExecutor(int numWorkers);
-    ~StreamingOrderedOutputThreadPoolExecutor() = default;
+    ~StreamingOrderedOutputThreadPoolExecutor();
 
     // append work to the queue
     void queueWork(std::function<ReturnType()> work);

src/decoder.cpp

@@ -88,16 +88,19 @@ void Decoder::main_loop() {
     auto bytes_read = read(input_fd_, rx_buffer, sizeof(rx_buffer));
 
     if (errno == EINTR) {
+        stop = 1;
         return;
     } else if (bytes_read < 0) {
         throw std::runtime_error("Read error");
     } else if (bytes_read == 0) {
+        stop = 1;
         return;
     }
 
     if (output_file_fd_.has_value()) {
         if (write(*output_file_fd_, rx_buffer, bytes_read) != bytes_read) {
             // unable to write to output TODO: possible log or fail hard
+            stop = 1;
             return;
         }
     }

src/iq_stream_decoder.cpp

@@ -36,8 +36,14 @@ IQStreamDecoder::IQStreamDecoder(std::shared_ptr<LowerMac> lower_mac,
 #endif
 }
 
+IQStreamDecoder::~IQStreamDecoder() {
+    // TODO: replace this crude hack that keeps the StreamingOrderedOutputThreadPoolExecutor<...> get function from blocking on programm stop
+    threadPool_->queueWork([]() { return std::vector<std::function<void()>>(); });
+    upperMacWorkerThread_.join();
+}
+
 void IQStreamDecoder::upperMacWorker() {
-    while (true) {
+    while (!stop) {
         for (auto func : threadPool_->get()) {
             func();
         }

src/main.cpp

@@ -5,8 +5,9 @@
 #include <stdio.h>
 
 #include <decoder.hpp>
+#include <signal_handler.hpp>
 
-static bool stop = false;
+volatile bool stop = false;
 
 void sigint_handler(int s) {
     (void)s;

src/streaming_ordered_output_thread_pool_executor.cpp

@@ -32,8 +32,14 @@ StreamingOrderedOutputThreadPoolExecutor<ReturnType>::StreamingOrderedOutputThre
     }
 }
 
+template <typename ReturnType>
+StreamingOrderedOutputThreadPoolExecutor<ReturnType>::~StreamingOrderedOutputThreadPoolExecutor() {
+    for (auto& t : workers)
+        t.join();
+}
+
 template <typename ReturnType> void StreamingOrderedOutputThreadPoolExecutor<ReturnType>::worker() {
-    while (true) {
+    while (!stop) {
         std::optional<std::pair<uint64_t, std::function<ReturnType()>>> work{};
 
         {