src/NLog/LogEventInfo.cs (2)

72-72: Strengthen memory visibility on lock‑free cache reads (optional)

To guarantee readers always see fully published nodes across CPUs, consider volatile semantics for the head and volatile reads during traversal.

Option A (simplest): make the head volatile.

-        private LayoutCacheLinkedNode? _layoutCache;
+        private volatile LayoutCacheLinkedNode? _layoutCache;

Option B: use Volatile.Read on head and next in TryGet.

-            var nodeHead = _layoutCache;
+            var nodeHead = Volatile.Read(ref _layoutCache);
             while (nodeHead != null)
             {
                 if (ReferenceEquals(nodeHead.Key, layout))
                 {
                     value = nodeHead.Value;
                     return true;
                 }
-                nodeHead = nodeHead.Next;
+                nodeHead = Volatile.Read(ref nodeHead.Next);
             }

Also applies to: 637-646

---

814-825: Invalidate layout cache when message/parameters change (avoid stale values)

If Message/Parameters/FormatProvider mutate after precalc, cached layout outputs can become stale. Consider clearing the cache in ResetFormattedMessage.

         private void ResetFormattedMessage(bool rebuildMessageTemplateParameters)
         {
             if (_messageFormatter is null || _messageFormatter.Target is ILogMessageFormatter)
             {
                 _formattedMessage = null;
+                // Cached layout values may depend on message/parameters/format-provider
+                Volatile.Write(ref _layoutCache, null);
             }

Please confirm this matches intended lifecycle (i.e., LogEventInfo not mutated after layouts start precalculating). If mutation never happens post-precalc, this can be skipped.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

src/NLog/LogEventInfo.cs (1)

625-636: Critical race condition allows duplicate cache entries.

The duplicate check on line 630 reads _layoutCache directly via TryGetCachedLayoutValue, but another thread can insert the same layout between that check and the CAS on line 634. This race condition will create duplicate entries in the linked list, defeating the memory optimization goal and degrading lookup performance.

Additionally, creating the new node (line 625) before checking for existence wastes an allocation when the layout is already cached.

Consider this approach to prevent duplicates:

 internal void AddCachedLayoutValue(Layout layout, object? value)
 {
-    var newNode = new LayoutCacheLinkedNode(layout, value);
-    var nodeHead = _layoutCache;
+    if (TryGetCachedLayoutValue(layout, out _))
+        return;
 
+    var newNode = new LayoutCacheLinkedNode(layout, value);
+    var nodeHead = _layoutCache;
     do
     {
-        if (nodeHead != null && TryGetCachedLayoutValue(layout, out _))
-            return;
-
+        // Check if layout exists in the current snapshot
+        var current = nodeHead;
+        while (current != null)
+        {
+            if (ReferenceEquals(current.Key, layout))
+                return;
+            current = current.Next;
+        }
+        
         newNode.Next = nodeHead;
         nodeHead = Interlocked.CompareExchange(ref _layoutCache, newNode, nodeHead);
     }
     while (!ReferenceEquals(nodeHead, newNode.Next));
 }

This checks the snapshot (nodeHead) rather than re-reading _layoutCache, reducing (though not eliminating) the race window. Note that duplicates may still occur under high concurrency, but this significantly reduces the likelihood.

Based on past review comments.

src/NLog/LogEventInfo.cs (1)

641-654: Consider using volatile read for better memory visibility.

The plain read of _layoutCache (line 641) might not immediately see updates from other threads on architectures with weaker memory models. While .NET's memory model is relatively strong and this is unlikely to cause issues in practice, using Volatile.Read would provide stronger guarantees.

Apply this diff for explicit memory ordering:

 internal bool TryGetCachedLayoutValue(Layout layout, out object? value)
 {
-    var nodeHead = _layoutCache;
+    var nodeHead = Volatile.Read(ref _layoutCache);
     while (nodeHead != null)
     {

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro