Development: 1.6.0

.devcontainer/devcontainer.json

@@ -0,0 +1,19 @@
+{
+  "name": "SRT Development",
+  "dockerFile": "../docker/Dockerfile",
+  "workspaceFolder": "/srt_build_env",
+  "workspaceMount": "source=${localWorkspaceFolder},target=/srt_build_env,type=bind",
+  "customizations": {
+    "vscode": {
+      "settings": {
+        "terminal.integrated.defaultProfile.linux": "bash"
+      },
+      "extensions": [
+        "ms-vscode.cpptools",
+        "ms-vscode.cmake-tools",
+        "twxs.cmake"
+      ]
+    }
+  },
+  "remoteUser": "srt-dev"
+}

.github/workflows/s390x-focal.yaml

@@ -34,8 +34,8 @@ jobs:
           apt-get -y install tzdata &&
           uname -a &&
           lscpu | grep Endian &&
-          apt-get -y install cmake g++ libssl-dev git && 
+          apt-get -y install cmake g++ libssl-dev git python && 
           mkdir _build && cd _build &&
-          cmake ../ -DENABLE_ENCRYPTION=ON -DENABLE_UNITTESTS=ON -DENABLE_BONDING=ON -DENABLE_TESTING=ON -DENABLE_EXAMPLES=ON &&
-          cmake --build ./ &&
+          cmake --debug-output ../ -DENABLE_ENCRYPTION=ON -DENABLE_UNITTESTS=ON -DENABLE_BONDING=ON -DENABLE_TESTING=ON -DENABLE_EXAMPLES=ON &&
+          cmake --build ./ --parallel &&
           ./test-srt -disable-ipv6"

apps/logsupport.cpp → ATTIC/logsupport.cpp

@@ -17,15 +17,20 @@
 #include "logsupport.hpp"
 #include "../srtcore/srt.h"
 #include "../srtcore/utilities.h"
+#include "ofmt.h"
 
 using namespace std;
+using namespace srt;
+
+namespace hvu
+{
 
 // This is based on codes taken from <sys/syslog.h>
 // This is POSIX standard, so it's not going to change.
 // Haivision standard only adds one more severity below
 // DEBUG named DEBUG_TRACE to satisfy all possible needs.
 
-map<string, int> srt_level_names
+map<string, int> level_names
 {
     { "alert", LOG_ALERT },
     { "crit", LOG_CRIT },
@@ -46,17 +51,17 @@ map<string, int> srt_level_names
 
 
 
-srt_logging::LogLevel::type SrtParseLogLevel(string level)
+hvu::logging::LogLevel::type ParseLogLevel(string level)
 {
-    using namespace srt_logging;
+    using namespace hvu::logging;
 
     if ( level.empty() )
         return LogLevel::fatal;
 
     if ( isdigit(level[0]) )
     {
         long lev = strtol(level.c_str(), 0, 10);
-        if ( lev >= SRT_LOG_LEVEL_MIN && lev <= SRT_LOG_LEVEL_MAX )
+        if ( lev >= HVU_LOG_LEVEL_MIN && lev <= HVU_LOG_LEVEL_MAX )
             return LogLevel::type(lev);
 
         cerr << "ERROR: Invalid loglevel number: " << level << " - fallback to FATAL\n";
@@ -91,24 +96,13 @@ struct ToLowerFormat
     }
 };
 
-void LogFANames::Install(string upname, int value)
-{
-    string id;
-    transform(upname.begin(), upname.end(), back_inserter(id), ToLowerFormat());
-    namemap[id] = value;
-}
 
 // See logsupport_appdefs.cpp for log FA definitions
 LogFANames srt_transmit_logfa_names;
 
-const map<string, int> SrtLogFAList()
+set<hvu::logging::LogFA> ParseLogFA(string fa, set<string>* punknown)
 {
-    return srt_transmit_logfa_names.namemap;
-}
-
-set<srt_logging::LogFA> SrtParseLogFA(string fa, set<string>* punknown)
-{
-    using namespace srt_logging;
+    using namespace hvu::logging;
 
     set<LogFA> fas;
 
@@ -173,7 +167,7 @@ set<srt_logging::LogFA> SrtParseLogFA(string fa, set<string>* punknown)
 
 void ParseLogFASpec(const vector<string>& speclist, string& w_on, string& w_off)
 {
-    std::ostringstream son, soff;
+    hvu::ofmtbufstream son, soff;
 
     for (auto& s: speclist)
     {
@@ -202,4 +196,5 @@ void ParseLogFASpec(const vector<string>& speclist, string& w_on, string& w_off)
     w_off = soffs.empty() ? string() : soffs.substr(1);
 }
 
+}
 

apps/logsupport.hpp → ATTIC/logsupport.hpp

@@ -14,21 +14,16 @@
 #include <string>
 #include <map>
 #include <vector>
-#include "../srtcore/srt.h"
-#include "../srtcore/logging_api.h"
+#include "logging_api.h"
 
-srt_logging::LogLevel::type SrtParseLogLevel(std::string level);
-std::set<srt_logging::LogFA> SrtParseLogFA(std::string fa, std::set<std::string>* punknown = nullptr);
+namespace hvu
+{
+
+hvu::logging::LogLevel::type ParseLogLevel(std::string level);
+std::set<hvu::logging::LogFA> ParseLogFA(std::string fa, std::set<std::string>* punknown = nullptr);
 void ParseLogFASpec(const std::vector<std::string>& speclist, std::string& w_on, std::string& w_off);
-const std::map<std::string, int> SrtLogFAList();
 
-SRT_API extern std::map<std::string, int> srt_level_names;
 
-struct LogFANames
-{
-    std::map<std::string, int> namemap;
-    void Install(std::string upname, int value);
-    LogFANames();
-};
+}
 
 #endif

ATTIC/sync_scraps.cpp

@@ -0,0 +1,42 @@
+#include <string>
+#include "ofmt.h"
+
+namespace srt
+{
+namespace sync
+{
+
+// Old implementation for FormatTime
+std::string FormatTime1(const steady_clock::time_point& timestamp)
+{
+    using namespace hvu;
+    if (is_zero(timestamp))
+    {
+        // Use special string for 0
+        return "00:00:00.000000 [TMTN]";
+    }
+
+    const int decimals = clockSubsecondPrecision();
+    const uint64_t total_sec = count_seconds(timestamp.time_since_epoch());
+    const uint64_t days = total_sec / (60 * 60 * 24);
+    const uint64_t hours = total_sec / (60 * 60) - days * 24;
+    const uint64_t minutes = total_sec / 60 - (days * 24 * 60) - hours * 60;
+    const uint64_t seconds = total_sec - (days * 24 * 60 * 60) - hours * 60 * 60 - minutes * 60;
+    steady_clock::time_point frac = timestamp - seconds_from(total_sec);
+    ofmt_bufs out;
+    if (days)
+        out << days << OFMT_SV("D+");
+
+    fmtc d02 = fmtc().dec().fillzero().width(2),
+         dec0 = fmtc().dec().fillzero().width(decimals);
+
+    out << fmt(hours, d02) << OFMT_SV(":")
+        << fmt(minutes, d02) << OFMT_SV(":")
+        << fmt(seconds, d02) << OFMT_SV(".")
+        << fmt(frac.time_since_epoch().count(), dec0)
+        << OFMT_SV(" [TMTN]");
+    return out.str();
+}
+
+}
+}

ATTIC/sync_timer.cpp

@@ -0,0 +1,126 @@
+#include "sync_timer.h"
+
+namespace srt
+{
+namespace sync
+{
+
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Timer
+//
+////////////////////////////////////////////////////////////////////////////////
+
+CTimer::CTimer()
+{
+}
+
+
+CTimer::~CTimer()
+{
+}
+
+// This function sleeps up to the given time, then exits.
+// Meanwhile it can be influenced from another thread by calling:
+// - tick(): exit waiting, but re-check the end time and fall back to sleep if not reached
+// - interrupt(): exit waiting with setting wait time to now() so that it exits immediately
+//
+// This function returns true if it has exit on the originally set time.
+// If the time was changed due to being interrupted and it did really exit before
+// that time, false is returned.
+bool CTimer::sleep_until(TimePoint<steady_clock> tp)
+{
+    // The class member m_sched_time can be used to interrupt the sleep.
+    // Refer to Timer::interrupt().
+    enterCS(m_event.mutex());
+    m_tsSchedTime = tp;
+    leaveCS(m_event.mutex());
+
+#if SRT_BUSY_WAITING
+    wait_busy();
+#else
+    wait_stalled();
+#endif
+
+    // Returning false means that sleep was early interrupted
+    return m_tsSchedTime.load() >= tp;
+}
+
+void CTimer::wait_stalled()
+{
+    TimePoint<steady_clock> cur_tp = steady_clock::now();
+    {
+        UniqueLock elk (m_event.mutex());
+        while (cur_tp < m_tsSchedTime.load())
+        {
+            m_event.wait_until(elk, m_tsSchedTime);
+            cur_tp = steady_clock::now();
+        }
+    }
+}
+
+void srt::sync::CTimer::wait_busy()
+{
+#if defined(_WIN32)
+    // 10 ms on Windows: bad accuracy of timers
+    const steady_clock::duration
+        td_threshold = milliseconds_from(10);
+#else
+    // 1 ms on non-Windows platforms
+    const steady_clock::duration
+        td_threshold = milliseconds_from(1);
+#endif
+
+    TimePoint<steady_clock> cur_tp = steady_clock::now();
+    {
+        UniqueLock elk (m_event.mutex());
+        while (cur_tp < m_tsSchedTime.load())
+        {
+            steady_clock::duration td_wait = m_tsSchedTime.load() - cur_tp;
+            if (td_wait <= 2 * td_threshold)
+                break;
+
+            td_wait -= td_threshold;
+            m_event.wait_for(elk, td_wait);
+
+            cur_tp = steady_clock::now();
+        }
+
+        while (cur_tp < m_tsSchedTime.load())
+        {
+            InvertedLock ulk (m_event.mutex());
+#ifdef IA32
+            __asm__ volatile ("pause; rep; nop; nop; nop; nop; nop;");
+#elif IA64
+            __asm__ volatile ("nop 0; nop 0; nop 0; nop 0; nop 0;");
+#elif AMD64
+            __asm__ volatile ("nop; nop; nop; nop; nop;");
+#elif defined(_WIN32) && !defined(__MINGW32__)
+            __nop();
+            __nop();
+            __nop();
+            __nop();
+            __nop();
+#endif
+            cur_tp = steady_clock::now();
+        }
+    }
+}
+
+
+void CTimer::interrupt()
+{
+    UniqueLock lck(m_event.mutex());
+    m_tsSchedTime = steady_clock::now();
+    m_event.notify_all();
+}
+
+
+void CTimer::tick()
+{
+    m_event.notify_one();
+}
+
+}
+}

ATTIC/sync_timer.h

@@ -0,0 +1,44 @@
+#include "sync.h" // Requires CEvent
+
+namespace srt
+{
+namespace sync
+{
+
+class CTimer
+{
+public:
+    CTimer();
+    ~CTimer();
+
+public:
+    /// Causes the current thread to block until
+    /// the specified time is reached.
+    /// Sleep can be interrupted by calling interrupt()
+    /// or woken up to recheck the scheduled time by tick()
+    /// @param tp target time to sleep until
+    ///
+    /// @return true  if the specified time was reached
+    ///         false should never happen
+    bool sleep_until(steady_clock::time_point tp);
+
+    /// Resets target wait time and interrupts waiting
+    /// in sleep_until(..)
+    void interrupt();
+
+    /// Wakes up waiting thread (sleep_until(..)) without
+    /// changing the target waiting time to force a recheck
+    /// of the current time in comparison to the target time.
+    void tick();
+
+private:
+    CEvent m_event;
+    sync::AtomicClock<steady_clock> m_tsSchedTime;
+
+    void wait_busy();
+    void wait_stalled();
+};
+
+
+}
+}