Withdrawn changes from #2858 as they break ABI compat

srtcore/api.cpp

@@ -4656,29 +4656,29 @@
 {
     ScopedLock gg(srt_logger_config.mutex);
     srt_logger_config.max_level = ll;
-    srt_logger_config.updateLoggersState();
+//    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();
+//    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();
+//    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();
+//    srt_logger_config.updateLoggersState();
 }
 
 void resetlogfa(const int* fara, size_t fara_size)
@@ -4687,7 +4687,7 @@
     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();
+//    srt_logger_config.updateLoggersState();
 }
 
 void setlogstream(std::ostream& stream)

srtcore/logging.cpp

@@ -23,69 +23,71 @@
 namespace srt_logging
 {
 
+/* Blocked temporarily until 1.6.0. This causes ABI incompat with 1.5.0 line.
+
 // 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 @@
 #include <iostream>
 #include <iomanip>
 #include <set>
-#include <vector>
+//#include <vector>
 #include <sstream>
 #include <cstdarg>
 #ifdef _WIN32
@@ -116,7 +116,7 @@
     void* loghandler_opaque;
     srt::sync::Mutex mutex;
     int flags;
-    std::vector<struct LogDispatcher*> loggers;
+ //   std::vector<struct LogDispatcher*> loggers;
 
     LogConfig(const fa_bitset_t& efa,
             LogLevel::type l = LogLevel::warning,
@@ -139,10 +139,11 @@
 
     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 +155,7 @@
     LogLevel::type level;
     static const size_t MAX_PREFIX_SIZE = 32;
     char prefix[MAX_PREFIX_SIZE+1];
-    srt::sync::atomic<bool> enabled;
+//    srt::sync::atomic<bool> enabled;
     LogConfig* src_config;
 
     bool isset(int flg) { return (src_config->flags & flg) != 0; }
@@ -165,7 +166,7 @@
             const char* logger_pfx /*[[nullable]]*/, LogConfig& config):
         fa(functional_area),
         level(log_level),
-        enabled(false),
+//        enabled(false),
         src_config(&config)
     {
         // XXX stpcpy desired, but not enough portable
@@ -193,18 +194,17 @@
             prefix[MAX_PREFIX_SIZE] = '\0';
 #endif
         }
-        config.subscribe(this);
-        Update();
+//      config.subscribe(this);
+//      Update();
     }
 
     ~LogDispatcher()
     {
-        src_config->unsubscribe(this);
+//        src_config->unsubscribe(this);
     }
 
-    void Update();
-
-    bool CheckEnabled() { return enabled; }
+ //   void Update();
+    bool CheckEnabled(); // { return enabled; }
 
     void CreateLogLinePrefix(std::ostringstream&);
     void SendLogLine(const char* file, int line, const std::string& area, const std::string& sl);
@@ -428,6 +428,22 @@
     }
 };
 
+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 +494,24 @@
 
 #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
-