Remove duplicate logger when used with static+dyanmic

+ Change from a pull to a push model, to push the logger instance
  from the loader to the validation layer to remove duplication.
+ Remove resource consumption when no logger is used

Signed-off-by: Russell McGuire <russell.w.mcguire@intel.com>

Author: rwmcguir

source/layers/validation/ze_validation_layer.cpp

@@ -11,9 +11,6 @@
 #include "param_validation.h"
 #include <memory>
 
-// Forward declaration — resolves at link time against ze_loader.so.
-extern "C" ZE_DLLEXPORT std::shared_ptr<loader::ZeLogger> *ZE_APICALL zelLoaderGetLogger();
-
 namespace validation_layer
 {
     context_t& context = context_t::getInstance();
@@ -28,18 +25,16 @@ namespace validation_layer
         enableThreadingValidation = getenv_tobool( "ZE_ENABLE_THREADING_VALIDATION" );
         verboseLogging = getenv_tobool( "ZEL_LOADER_LOGGING_ENABLE_SUCCESS_PRINT" );
 
-        // Prefer the loader's already-constructed logger so both components
-        // share a single file handle, mutex, and startup banner.
-        // Fall back to creating an independent logger (e.g. static build).
-#ifndef L0_STATIC_LOADER_BUILD
-        auto *loaderLog = zelLoaderGetLogger();
-        if (loaderLog && *loaderLog) {
-            logger = *loaderLog;
-        } else
-#endif
-        {
-            logger = loader::createLogger("Validation Layer");
-        }
+        // Initialize logger to a no-op sentinel (level=off, no file/console I/O, no banner).
+        // This is purely crash protection: in normal operation the loader calls
+        // zelLoaderSetLogger() immediately after dlopen — before the DDI tables
+        // go live — so no real log call ever hits this sentinel.
+        //
+        // Thread-safety note: zelLoaderSetLogger() writes this field once, on the
+        // init thread, before zeDdiTable.exchange() makes the validation layer
+        // reachable from other threads.  The non-atomic shared_ptr assignment is
+        // therefore safe in practice; no mutex is needed here.
+        logger = std::make_shared<loader::ZeLogger>(); // no-op sentinel: no sink, no mutex, no syscalls
     }
 
     ///////////////////////////////////////////////////////////////////////////////
@@ -68,6 +63,17 @@ zelLoaderGetVersion(zel_component_version_t *version)
     return ZE_RESULT_SUCCESS;
 }
 
+/// @brief Called by the loader immediately after dlopen to share its logger.
+///        Replaces the fallback logger created in the constructor so that
+///        validation-layer messages flow through the same sink as the loader.
+ZE_DLLEXPORT void ZE_APICALL
+zelLoaderSetLogger(std::shared_ptr<loader::ZeLogger> *loaderLogger)
+{
+    if (loaderLogger && *loaderLogger) {
+        validation_layer::context_t::getInstance().logger = *loaderLogger;
+    }
+}
+
 #if defined(__cplusplus)
 };
 #endif

source/loader/ze_loader.cpp

@@ -778,6 +778,15 @@ namespace loader
                     }
 #endif
                 }
+                // Inject this loader instance's logger into the validation layer
+                // so both share a single file handle and mutex.
+                using SetLoggerFn = void (*)(std::shared_ptr<loader::ZeLogger> *);
+                auto setLogger = reinterpret_cast<SetLoggerFn>(
+                    GET_FUNCTION_PTR(validationLayer, "zelLoaderSetLogger"));
+                if (setLogger) {
+                    setLogger(&zel_logger);
+                }
+
                 auto getVersion = reinterpret_cast<getVersion_t>(
                     GET_FUNCTION_PTR(validationLayer, "zelLoaderGetVersion"));
                 zel_component_version_t compVersion;

source/utils/ze_logger.cpp

@@ -167,6 +167,10 @@ LogLevel logLevelFromString(const std::string &s) {
 // ---------------------------------------------------------------------------
 // ZeLogger
 // ---------------------------------------------------------------------------
+ZeLogger::ZeLogger()
+    : _level(LogLevel::off), _pattern(), _sink(nullptr)
+{}
+
 ZeLogger::ZeLogger(const std::string &log_path, LogLevel level, const std::string &pattern)
     : _level(level), _pattern(pattern), _sink(new LogSink(log_path))
 {
@@ -192,7 +196,7 @@ LogLevel ZeLogger::getLevel() const {
 }
 
 void ZeLogger::flush() {
-    _sink->flush();
+    if (_sink) _sink->flush();
 }
 
 // ---------------------------------------------------------------------------
@@ -305,7 +309,7 @@ void ZeLogger::formatLine(LogLevel msg_level, const std::string &msg, std::strin
 }
 
 void ZeLogger::write(LogLevel msg_level, const std::string &msg) {
-    if (msg_level < _level) {
+    if (!_sink || msg_level < _level) {
         return;
     }
     // Reuse a thread_local buffer to avoid a heap allocation per log call.
@@ -500,7 +504,8 @@ std::shared_ptr<ZeLogger> createLogger(const std::string &caller) {
     //   logging_enabled=1, log_console=0  → file sink, configured level
     //   logging_enabled=1, log_console=1  → console (stderr), configured level
     if (!logging_enabled && !log_console) {
-        return std::make_shared<ZeLogger>(/*use_stderr=*/true, LogLevel::off, log_pattern);
+        // Pure no-op: no sink, no mutex, no isatty() syscall, no pattern string.
+        return std::make_shared<ZeLogger>();
     }
 
     LogLevel level = logLevelFromString(log_level);

source/utils/ze_logger.h

@@ -46,6 +46,9 @@ struct LogSink;
 // are produced by this class so it can be unloaded by dlclose().
 class ZeLogger {
 public:
+    // No-op constructor: level=off, no sink, no I/O, no syscalls, no mutex.
+    // Use this (or createLogger() with logging disabled) for zero-overhead paths.
+    ZeLogger();
     // File sink constructor
     ZeLogger(const std::string &log_path, LogLevel level, const std::string &pattern);
     // Console sink constructor (stderr or stdout)