Merge pull request #141 from tarekgh/PerfEnhancement

Tracking Perf enhancement in multi-threading scenario

Author: tonerdo

src/coverlet.core/Coverage.cs

@@ -183,15 +183,15 @@ private void CalculateCoverage()
                         {
                             int ordinal = int.Parse(info[3]);
                             var branch = document.Branches[(start, ordinal)];
-                            branch.Hits = hits;
+                            branch.Hits += hits;
                         }
                         else
                         {
                             int end = int.Parse(info[3]);
                             for (int j = start; j <= end; j++)
                             {
                                 var line = document.Lines[j];
-                                line.Hits = hits;
+                                line.Hits += hits;
                             }
                         }
                     }

src/coverlet.tracker/CoverageTracker.cs

@@ -7,25 +7,39 @@ namespace Coverlet.Tracker
 {
     public static class CoverageTracker
     {
-        private static Dictionary<string, Dictionary<string, int>> _events;
+        private static List<Dictionary<string, Dictionary<string, int>>> _events;
+
+        [ThreadStatic]
+        private static Dictionary<string, Dictionary<string, int>> t_events;
 
         [ExcludeFromCodeCoverage]
         static CoverageTracker()
         {
-            _events = new Dictionary<string, Dictionary<string, int>>();
+            _events = new List<Dictionary<string, Dictionary<string, int>>>();
             AppDomain.CurrentDomain.ProcessExit += new EventHandler(CurrentDomain_ProcessExit);
             AppDomain.CurrentDomain.DomainUnload += new EventHandler(CurrentDomain_ProcessExit);
         }
 
         [ExcludeFromCodeCoverage]
         public static void MarkExecuted(string file, string evt)
         {
-            lock (_events)
+            if (t_events == null)
+            {
+                t_events = new Dictionary<string, Dictionary<string, int>>();
+                lock (_events)
+                {
+                    _events.Add(t_events);
+                }
+            }
+
+            // We are taking the lock only for synchronizing with CurrentDomain_ProcessExit event
+            // but the lock should be fast as the thread shouldn't block before getting process exit event
+            lock (t_events)
             {
-                if (!_events.TryGetValue(file, out var fileEvents))
+                if (!t_events.TryGetValue(file, out var fileEvents))
                 {
                     fileEvents = new Dictionary<string, int>();
-                    _events.Add(file, fileEvents);
+                    t_events.Add(file, fileEvents);
                 }
 
                 if (!fileEvents.TryGetValue(evt, out var count))
@@ -42,16 +56,30 @@ public static void MarkExecuted(string file, string evt)
         [ExcludeFromCodeCoverage]
         public static void CurrentDomain_ProcessExit(object sender, EventArgs e)
         {
+            Dictionary<string, bool> encounteredFile = new Dictionary<string, bool>();
+
             lock (_events)
             {
-                foreach (var files in _events)
+                foreach (var localEvents in _events)
                 {
-                    using (var fs = new FileStream(files.Key, FileMode.Create))
-                    using (var sw = new StreamWriter(fs))
+                    lock (localEvents)
                     {
-                        foreach (var evt in files.Value)
+                        foreach (var files in localEvents)
                         {
-                            sw.WriteLine($"{evt.Key},{evt.Value}");
+                            FileMode mode = FileMode.Append;
+                            if (!encounteredFile.TryGetValue(files.Key, out bool b))
+                            {
+                                encounteredFile.Add(files.Key, true);
+                                mode = FileMode.Create;
+                            }
+                            using (var fs = new FileStream(files.Key, mode))
+                            using (var sw = new StreamWriter(fs))
+                            {
+                                foreach (var evt in files.Value)
+                                {
+                                    sw.WriteLine($"{evt.Key},{evt.Value}");
+                                }
+                            }
                         }
                     }
                 }

test/coverlet.core.performancetest/PerformanceTest.cs

@@ -1,4 +1,6 @@
 using coverlet.testsubject;
+using System.Threading.Tasks;
+using System.Collections.Generic;
 using Xunit;
 
 namespace coverlet.core.performancetest
@@ -18,10 +20,14 @@ public void TestPerformance(int iterations)
         {
             var big = new BigClass();
 
+            List<Task> tasks = new List<Task>();
+
             for (var i = 0; i < iterations; i++)
             {
-                big.Do(i);
+                tasks.Add(Task.Run(() => big.Do(i)));
             }
+
+            Task.WaitAll(tasks.ToArray());
         }
     }
 }