Withdrawn changes from #2858 as they break ABI compat

srtcore/api.cpp

@@ -4656,29 +4656,25 @@ void setloglevel(LogLevel::type ll)
 {
     ScopedLock gg(srt_logger_config.mutex);
     srt_logger_config.max_level = ll;
-    srt_logger_config.updateLoggersState();
 }
 
 void addlogfa(LogFA fa)
 {
     ScopedLock gg(srt_logger_config.mutex);
     srt_logger_config.enabled_fa.set(fa, true);
-    srt_logger_config.updateLoggersState();
 }
 
 void dellogfa(LogFA fa)
 {
     ScopedLock gg(srt_logger_config.mutex);
     srt_logger_config.enabled_fa.set(fa, false);
-    srt_logger_config.updateLoggersState();
 }
 
 void resetlogfa(set<LogFA> fas)
 {
     ScopedLock gg(srt_logger_config.mutex);
     for (int i = 0; i <= SRT_LOGFA_LASTNONE; ++i)
         srt_logger_config.enabled_fa.set(i, fas.count(i));
-    srt_logger_config.updateLoggersState();
 }
 
 void resetlogfa(const int* fara, size_t fara_size)
@@ -4687,7 +4683,6 @@ void resetlogfa(const int* fara, size_t fara_size)
     srt_logger_config.enabled_fa.reset();
     for (const int* i = fara; i != fara + fara_size; ++i)
         srt_logger_config.enabled_fa.set(*i, true);
-    srt_logger_config.updateLoggersState();
 }
 
 void setlogstream(std::ostream& stream)

srtcore/logging.cpp

@@ -23,69 +23,6 @@ using namespace std;
 namespace srt_logging
 {
 
-// Note: subscribe() and unsubscribe() functions are being called
-// in the global constructor and destructor only, as the
-// Logger objects (and inside them also their LogDispatcher)
-// are being created. It's not predicted that LogDispatcher
-// object are going to be created any other way than as
-// global objects. Therefore the construction and destruction
-// of them happens always in the main thread.
-
-void LogConfig::subscribe(LogDispatcher* lg)
-{
-    vector<LogDispatcher*>::iterator p = std::find(loggers.begin(), loggers.end(), lg);
-    if (p != loggers.end())
-        return; // Do not register twice
-
-    loggers.push_back(lg);
-}
-
-void LogConfig::unsubscribe(LogDispatcher* lg)
-{
-    vector<LogDispatcher*>::iterator p = std::find(loggers.begin(), loggers.end(), lg);
-    if (p != loggers.end())
-    {
-        loggers.erase(p);
-    }
-}
-
-// This function doesn't have any protection on itself,
-// however the API functions from which it is called, call
-// it already under a mutex protection.
-void LogConfig::updateLoggersState()
-{
-    for (vector<LogDispatcher*>::iterator p = loggers.begin();
-            p != loggers.end(); ++p)
-    {
-        (*p)->Update();
-    }
-}
-
-void LogDispatcher::Update()
-{
-    bool enabled_in_fa = src_config->enabled_fa[fa];
-    enabled = enabled_in_fa && level <= src_config->max_level;
-}
-
-
-// SendLogLine can be compiled normally. It's intermediately used by:
-// - Proxy object, which is replaced by DummyProxy when !ENABLE_LOGGING
-// - PrintLogLine, which has empty body when !ENABLE_LOGGING
-void LogDispatcher::SendLogLine(const char* file, int line, const std::string& area, const std::string& msg)
-{
-    src_config->lock();
-    if ( src_config->loghandler_fn )
-    {
-        (*src_config->loghandler_fn)(src_config->loghandler_opaque, int(level), file, line, area.c_str(), msg.c_str());
-    }
-    else if ( src_config->log_stream )
-    {
-        (*src_config->log_stream) << msg;
-        src_config->log_stream->flush();
-    }
-    src_config->unlock();
-}
-
 
 #if ENABLE_LOGGING
 

srtcore/logging.h

@@ -20,7 +20,7 @@ written by
 #include <iostream>
 #include <iomanip>
 #include <set>
-#include <vector>
+//#include <vector>
 #include <sstream>
 #include <cstdarg>
 #ifdef _WIN32
@@ -116,7 +116,6 @@ struct LogConfig
     void* loghandler_opaque;
     srt::sync::Mutex mutex;
     int flags;
-    std::vector<struct LogDispatcher*> loggers;
 
     LogConfig(const fa_bitset_t& efa,
             LogLevel::type l = LogLevel::warning,
@@ -139,10 +138,6 @@ struct LogConfig
 
     SRT_ATTR_RELEASE(mutex)
     void unlock() { mutex.unlock(); }
-
-    void subscribe(LogDispatcher*);
-    void unsubscribe(LogDispatcher*);
-    void updateLoggersState();
 };
 
 // The LogDispatcher class represents the object that is responsible for
@@ -154,7 +149,6 @@ struct SRT_API LogDispatcher
     LogLevel::type level;
     static const size_t MAX_PREFIX_SIZE = 32;
     char prefix[MAX_PREFIX_SIZE+1];
-    srt::sync::atomic<bool> enabled;
     LogConfig* src_config;
 
     bool isset(int flg) { return (src_config->flags & flg) != 0; }
@@ -165,7 +159,6 @@ struct SRT_API LogDispatcher
             const char* logger_pfx /*[[nullable]]*/, LogConfig& config):
         fa(functional_area),
         level(log_level),
-        enabled(false),
         src_config(&config)
     {
         // XXX stpcpy desired, but not enough portable
@@ -193,18 +186,13 @@ struct SRT_API LogDispatcher
             prefix[MAX_PREFIX_SIZE] = '\0';
 #endif
         }
-        config.subscribe(this);
-        Update();
     }
 
     ~LogDispatcher()
     {
-        src_config->unsubscribe(this);
     }
 
-    void Update();
-
-    bool CheckEnabled() { return enabled; }
+    bool CheckEnabled();
 
     void CreateLogLinePrefix(std::ostringstream&);
     void SendLogLine(const char* file, int line, const std::string& area, const std::string& sl);
@@ -428,6 +416,22 @@ class Logger
     }
 };
 
+inline bool LogDispatcher::CheckEnabled()
+{
+    // Don't use enabler caching. Check enabled state every time.
+
+    // These assume to be atomically read, so the lock is not needed
+    // (note that writing to this field is still mutex-protected).
+    // It's also no problem if the level was changed at the moment
+    // when the enabler check is tested here. Worst case, the log
+    // will be printed just a moment after it was turned off.
+    const LogConfig* config = src_config; // to enforce using const operator[]
+    int configured_enabled_fa = config->enabled_fa[fa];
+    int configured_maxlevel = config->max_level;
+
+    return configured_enabled_fa && level <= configured_maxlevel;
+}
+
 
 #if HAVE_CXX11
 
@@ -478,7 +482,24 @@ inline void LogDispatcher::PrintLogLine(const char* file SRT_ATR_UNUSED, int lin
 
 #endif // HAVE_CXX11
 
+// SendLogLine can be compiled normally. It's intermediately used by:
+// - Proxy object, which is replaced by DummyProxy when !ENABLE_LOGGING
+// - PrintLogLine, which has empty body when !ENABLE_LOGGING
+inline void LogDispatcher::SendLogLine(const char* file, int line, const std::string& area, const std::string& msg)
+{
+    src_config->lock();
+    if ( src_config->loghandler_fn )
+    {
+        (*src_config->loghandler_fn)(src_config->loghandler_opaque, int(level), file, line, area.c_str(), msg.c_str());
+    }
+    else if ( src_config->log_stream )
+    {
+        (*src_config->log_stream) << msg;
+        (*src_config->log_stream).flush();
+    }
+    src_config->unlock();
 }
 
-#endif // INC_SRT_LOGGING_H
+}
 
+#endif // INC_SRT_LOGGING_H