Progress report when patching

Torch/Managers/PatchManager/DecoratedMethod.cs

@@ -27,11 +27,16 @@ namespace Torch.Managers.PatchManager
         private byte[] _revertData = null;
         private GCHandle? _pinnedPatch;
 
+        internal bool HasChanged()
+        {
+            return Prefixes.HasChanges() || Suffixes.HasChanges() || Transpilers.HasChanges();
+        }
+
         internal void Commit()
         {
             try
             {
-                if (!Prefixes.HasChanges() && !Suffixes.HasChanges() && !Transpilers.HasChanges())
+                if (!Prefixes.HasChanges(true) && !Suffixes.HasChanges(true) && !Transpilers.HasChanges(true))
                     return;
                 Revert();
 

Torch/Managers/PatchManager/MethodRewritePattern.cs

@@ -36,9 +36,11 @@ namespace Torch.Managers.PatchManager
 
             private int _hasChanges = 0;
 
-            internal bool HasChanges()
+            internal bool HasChanges(bool reset = false)
             {
+                if (reset)
                     return Interlocked.Exchange(ref _hasChanges, 0) != 0;
+                return _hasChanges != 0;
             }
 
             /// <summary>

Torch/Managers/PatchManager/PatchManager.cs

@@ -1,7 +1,9 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Reflection;
 using System.Runtime.CompilerServices;
+using System.Threading;
 using NLog;
 using Torch.API;
 using Torch.Managers.PatchManager.Transpile;
@@ -149,17 +151,38 @@ namespace Torch.Managers.PatchManager
         }
 
 
+        private static int _finishedPatchCount, _dirtyPatchCount;
+
+        private static void DoCommit(DecoratedMethod method)
+        {
+            if (!method.HasChanged())
+                return;
+            method.Commit();
+            int value = Interlocked.Increment(ref _finishedPatchCount);
+            var actualPercentage = (value * 100) / _dirtyPatchCount;
+            var currentPrintGroup = actualPercentage / 10;
+            var prevPrintGroup = (value - 1) * 10 / _dirtyPatchCount;
+            if (currentPrintGroup != prevPrintGroup && value >= 1)
+            {
+                _log.Info($"Patched {value}/{_dirtyPatchCount}.  ({actualPercentage:D2}%)");
+            }
+        }
+
         /// <inheritdoc cref="Commit"/>
         internal static void CommitInternal()
         {
             lock (_rewritePatterns)
             {
+                _log.Info("Patching begins...");
+                _finishedPatchCount = 0;
+                _dirtyPatchCount = _rewritePatterns.Values.Sum(x => x.HasChanged() ? 1 : 0);
 #if true
-                ParallelTasks.Parallel.ForEach(_rewritePatterns.Values, x => x.Commit());
+                ParallelTasks.Parallel.ForEach(_rewritePatterns.Values, DoCommit);
 #else
                 foreach (DecoratedMethod m in _rewritePatterns.Values)
-                        m.Commit();
+                    DoCommit(m);
 #endif
+                _log.Info("Patching done");
 
             }
         }