Changeset 11821

Timestamp:

01/26/15 09:29:05 (10 years ago)

Author:

ascheibe

Message:

#2112 merged r11596,r11597,r11600 into stable branch

Location:

stable

Files:

• . (modified) (1 prop)
• HeuristicLab.Core/3.3/Log.cs (modified) (5 diffs)
• HeuristicLab.Core/3.3/ThreadSafeLog.cs (modified) (2 diffs)
• HeuristicLab.Tests (modified) (1 prop)
• HeuristicLab.Tests/HeuristicLab-3.3/ThreadSafeLogTest.cs (modified) (2 diffs)

stable/HeuristicLab.Core/3.3/Log.cs

@@ -30 +30 @@
   [Item("Log", "A log for logging string messages.")]
   [StorableClass]
-  public class Log : Item, ILog, IStorableContent {
+  public sealed class Log : Item, ILog, IStorableContent {
     public string Filename { get; set; }
 
@@ -38 +38 @@
 
     [Storable]
-    protected IList<string> messages;
-    public virtual IEnumerable<string> Messages {
+    private IList<string> messages;
+    public IEnumerable<string> Messages {
       get { return messages; }
     }
 
     [Storable]
-    protected long maxMessageCount;
-    public virtual long MaxMessageCount {
+    private long maxMessageCount;
+    public long MaxMessageCount {
       get { return maxMessageCount; }
     }
 
     [StorableConstructor]
-    protected Log(bool deserializing) : base(deserializing) { }
-    protected Log(Log original, Cloner cloner)
+    private Log(bool deserializing) : base(deserializing) { }
+    private Log(Log original, Cloner cloner)
       : base(original, cloner) {
       this.messages = new List<string>(original.messages);
@@ -66 +66 @@
     }
 
-    public virtual void Clear() {
+    public void Clear() {
       messages.Clear();
       OnCleared();
     }
-    public virtual void LogMessage(string message) {
+    public void LogMessage(string message) {
       string s = FormatLogMessage(message);
       messages.Add(s);
@@ -76 +76 @@
       OnMessageAdded(s);
     }
-    public virtual void LogException(Exception ex) {
+    public void LogException(Exception ex) {
       string s = FormatException(ex);
       messages.Add(s);
@@ -82 +82 @@
       OnMessageAdded(s);
     }
-    protected virtual void CapMessages() {
+    private void CapMessages() {
       while (maxMessageCount >= 0 && messages.Count > maxMessageCount) {
         messages.RemoveAt(0);
       }
     }
-    protected virtual string FormatLogMessage(string message) {
+    public static string FormatLogMessage(string message) {
       return DateTime.Now.ToString() + "\t" + message;
     }
-    protected virtual string FormatException(Exception ex) {
+    public static string FormatException(Exception ex) {
       return DateTime.Now.ToString() + "\t" + "Exception occurred:" + Environment.NewLine + ErrorHandling.BuildErrorMessage(ex);
     }
 
     public event EventHandler<EventArgs<string>> MessageAdded;
-    protected virtual void OnMessageAdded(string message) {
+    private void OnMessageAdded(string message) {
       EventHandler<EventArgs<string>> handler = MessageAdded;
       if (handler != null) handler(this, new EventArgs<string>(message));
     }
     public event EventHandler Cleared;
-    protected virtual void OnCleared() {
+    private void OnCleared() {
       EventHandler handler = Cleared;
       if (handler != null) handler(this, EventArgs.Empty);

stable/HeuristicLab.Core/3.3/ThreadSafeLog.cs

@@ -21 +21 @@
 
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
 using HeuristicLab.Common;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -30 +29 @@
   [Item("ThreadSafeLog", "A thread-safe log for logging string messages.")]
   [StorableClass]
-  public sealed class ThreadSafeLog : Log {
-    private ReaderWriterLockSlim locker = new ReaderWriterLockSlim();
+  public sealed class ThreadSafeLog : Item, ILog, IStorableContent {
+    public string Filename { get; set; }
+    private ConcurrentQueue<string> messages;
 
-    public override IEnumerable<string> Messages {
-      get {
-        locker.EnterReadLock();
-        try {
-          return messages.ToArray(); // return copy of messages
-        } finally { locker.ExitReadLock(); }
-      }
+    public IEnumerable<string> Messages {
+      get { return messages.ToArray(); }
+    }
+
+    [Storable(Name = "messages")]
+    private IEnumerable<string> StorableMessages {
+      get { return Messages; }
+      set { messages = new ConcurrentQueue<string>(value); }
+    }
+
+    [Storable]
+    private long maxMessageCount;
+    public long MaxMessageCount {
+      get { return maxMessageCount; }
     }
 
     [StorableConstructor]
     private ThreadSafeLog(bool deserializing) : base(deserializing) { }
-    public ThreadSafeLog(long maxMessageCount = -1)
-      : base(maxMessageCount) {
+    private ThreadSafeLog(ThreadSafeLog original, Cloner cloner)
+      : base(original, cloner) {
+      this.messages = new ConcurrentQueue<string>(original.messages);
+      this.maxMessageCount = original.maxMessageCount;
+    }
+    public ThreadSafeLog(long maxMessageCount = int.MaxValue) {
+      this.messages = new ConcurrentQueue<string>();
+      this.maxMessageCount = maxMessageCount;
     }
 
-    private ThreadSafeLog(ThreadSafeLog original, Cloner cloner)
-      : base(original, cloner) { }
-
     public override IDeepCloneable Clone(Cloner cloner) {
-      locker.EnterReadLock();
-      try {
-        return new ThreadSafeLog(this, cloner);
-      } finally { locker.ExitReadLock(); }
+      return new ThreadSafeLog(this, cloner);
     }
 
-    public override void Clear() {
-      locker.EnterWriteLock();
-      try {
-        messages.Clear();
-      } finally { locker.ExitWriteLock(); }
+    public void Clear() {
+      messages = new ConcurrentQueue<string>();
       OnCleared();
     }
 
-    public override void LogMessage(string message) {
-      string s = FormatLogMessage(message);
-      locker.EnterWriteLock();
-      try {
-        messages.Add(s);
-        CapMessages();
-      } finally { locker.ExitWriteLock(); }
+    public void LogMessage(string message) {
+      var s = Log.FormatLogMessage(message);
+      messages.Enqueue(s);
+      CapMessages();
       OnMessageAdded(s);
     }
 
-    public override void LogException(Exception ex) {
-      string s = FormatException(ex);
-      locker.EnterWriteLock();
-      try {
-        messages.Add(s);
-        CapMessages();
-      } finally { locker.ExitWriteLock(); }
+    public void LogException(Exception ex) {
+      var s = Log.FormatException(ex);
+      messages.Enqueue(s);
+      CapMessages();
       OnMessageAdded(s);
+    }
+
+    private readonly object capLock = new object();
+    private void CapMessages() {
+      lock (capLock) {
+        string s;
+        while (messages.Count > maxMessageCount)
+          if (!messages.TryDequeue(out s)) break;
+      }
+    }
+
+    public event EventHandler<EventArgs<string>> MessageAdded;
+    private void OnMessageAdded(string message) {
+      var handler = MessageAdded;
+      if (handler != null) handler(this, new EventArgs<string>(message));
+    }
+
+    public event EventHandler Cleared;
+    private void OnCleared() {
+      var handler = Cleared;
+      if (handler != null) handler(this, EventArgs.Empty);
     }
   }

stable/HeuristicLab.Tests/HeuristicLab-3.3/ThreadSafeLogTest.cs

@@ -28 +28 @@
   [TestClass]
   public class ThreadSafeLogTest {
-
     [TestMethod]
     [TestCategory("General")]
@@ -43 +42 @@
       Assert.AreEqual(count, log.Messages.Count());
     }
+
+    [TestMethod]
+    [TestCategory("General")]
+    [TestProperty("Time", "short")]
+    public void ThreadSafeLogCapTest() {
+      int count = 10000;
+      int cap = 500;
+      ThreadSafeLog log = new ThreadSafeLog(cap);
+
+      Parallel.For(0, count, (i) => {
+        log.LogMessage("Message " + i); // write something
+        log.Messages.Count(); // iterate over all messages
+      });
+
+      Assert.AreEqual(cap, log.Messages.Count());
+    }
   }
 }