Remove ILifetimeStatistics interface

Author: mvphelps

src/TorchSharp/DisposeScope.cs

@@ -214,10 +214,10 @@ public void Detach(IEnumerable<IDisposable> disposables)
             foreach (var disposable in disposables) {
                 if (Disposables.Remove(disposable)) {
                     if (disposable is torch.Tensor tensor) {
-                        _disposeScopeManager.StatisticsInstance._TensorStatistics.DetachedFromScopeCount++;
+                        _disposeScopeManager.StatisticsInstance.TensorStatistics.DetachedFromScopeCount++;
                         tensor.OwningDisposeScope = null;
                     } else if (disposable is torch.nn.utils.rnn.PackedSequence sequence) {
-                        _disposeScopeManager.StatisticsInstance._PackedSequenceStatistics.DetachedFromScopeCount++;
+                        _disposeScopeManager.StatisticsInstance.PackedSequenceStatistics.DetachedFromScopeCount++;
                         sequence.OwningDisposeScope = null;
                     }
                 }
@@ -243,9 +243,9 @@ public IReadOnlyList<IDisposable> Attach(IEnumerable<IDisposable> disposables)
             foreach (var disposable in disposables) {
                 if (AddToOther(this, disposable)) {
                     if (disposable is torch.Tensor tensor) {
-                        _disposeScopeManager.StatisticsInstance._TensorStatistics.AttachedToScopeCount++;
+                        _disposeScopeManager.StatisticsInstance.TensorStatistics.AttachedToScopeCount++;
                     } else if (disposable is torch.nn.utils.rnn.PackedSequence sequence) {
-                        _disposeScopeManager.StatisticsInstance._PackedSequenceStatistics.AttachedToScopeCount++;
+                        _disposeScopeManager.StatisticsInstance.PackedSequenceStatistics.AttachedToScopeCount++;
                     }
                 }
                 result.Add(disposable);
@@ -404,10 +404,10 @@ internal HashSet<IDisposable> DetachAllAndDispose()
             var disposables = this.Disposables;
             foreach (var disposable in this.Disposables) {
                 if (disposable is torch.Tensor tensor) {
-                    this._disposeScopeManager!.StatisticsInstance._TensorStatistics.DetachedFromScopeCount++;
+                    this._disposeScopeManager!.StatisticsInstance.TensorStatistics.DetachedFromScopeCount++;
                     tensor.OwningDisposeScope = null;
                 } else if (disposable is torch.nn.utils.rnn.PackedSequence sequence) {
-                    this._disposeScopeManager!.StatisticsInstance._PackedSequenceStatistics.DetachedFromScopeCount++;
+                    this._disposeScopeManager!.StatisticsInstance.PackedSequenceStatistics.DetachedFromScopeCount++;
                     sequence.OwningDisposeScope = null;
                 }
             }

src/TorchSharp/DisposeScopeManager.cs

@@ -22,16 +22,16 @@ public class DisposeScopeManager
         {
             if (this.CurrentDisposeScope is null) {
                 if (item is torch.Tensor t) {
-                    StatisticsInstance._TensorStatistics.CreatedOutsideScopeCount++;
+                    StatisticsInstance.TensorStatistics.CreatedOutsideScopeCount++;
                 } else if (item is torch.nn.utils.rnn.PackedSequence p) {
-                    StatisticsInstance._PackedSequenceStatistics.CreatedOutsideScopeCount++;
+                    StatisticsInstance.PackedSequenceStatistics.CreatedOutsideScopeCount++;
                 }
                 return null;
             } else {
                 if (item is torch.Tensor t) {
-                    StatisticsInstance._TensorStatistics.CreatedInScopeCount++;
+                    StatisticsInstance.TensorStatistics.CreatedInScopeCount++;
                 } else if (item is torch.nn.utils.rnn.PackedSequence p) {
-                    StatisticsInstance._PackedSequenceStatistics.CreatedInScopeCount++;
+                    StatisticsInstance.PackedSequenceStatistics.CreatedInScopeCount++;
                 }
                 this.CurrentDisposeScope.Disposables.Add(item);
                 return CurrentDisposeScope;
@@ -41,17 +41,17 @@ public class DisposeScopeManager
         internal void DisposingOnCurrentScope(torch.Tensor item)
         {
             if (item.OwningDisposeScope == null) {
-                StatisticsInstance._TensorStatistics.DisposedOutsideScopeCount++;
+                StatisticsInstance.TensorStatistics.DisposedOutsideScopeCount++;
             } else {
-                StatisticsInstance._TensorStatistics.DisposedInScopeCount++;
+                StatisticsInstance.TensorStatistics.DisposedInScopeCount++;
             }
         }
         internal void DisposingOnCurrentScope(torch.nn.utils.rnn.PackedSequence item)
         {
             if (item.OwningDisposeScope == null) {
-                StatisticsInstance._PackedSequenceStatistics.DisposedOutsideScopeCount++;
+                StatisticsInstance.PackedSequenceStatistics.DisposedOutsideScopeCount++;
             } else {
-                StatisticsInstance._PackedSequenceStatistics.DisposedInScopeCount++;
+                StatisticsInstance.PackedSequenceStatistics.DisposedInScopeCount++;
             }
         }
         internal void RemoveDisposeScope(DisposeScope disposeScope)

src/TorchSharp/ThreadDisposeScopeStatistics.cs

@@ -1,113 +1,135 @@
 #nullable enable
 using System.Text;
-using TorchSharp;
 
 namespace TorchSharp
 {
-    public interface ILifetimeStatistics
+
+    /// <summary>
+    /// Keeps track of the combined Tensor and PackedSequence statistics for the current thread. Can be queried to figure out performance/memory issues.
+    /// </summary>
+    public class ThreadDisposeScopeStatistics
     {
         /// <summary>
-        /// The number of disposables that were created on this thread, but weren't captured by a DisposeScope.
+        /// The total number of Tensors and PackedSequence instances that were created on this thread, but weren't
+        /// captured by a DisposeScope.
         /// </summary>
-        long CreatedOutsideScopeCount { get; }
+        public long CreatedOutsideScopeCount => TensorStatistics.CreatedOutsideScopeCount +
+                                                PackedSequenceStatistics.CreatedOutsideScopeCount;
+
         /// <summary>
-        /// The number of disposables that were Disposed on this thread, but weren't captured by a DisposeScope.
+        /// The number of Tensors and PackedSequence instances that were Disposed on this thread, but weren't
+        /// captured by a DisposeScope.
         /// </summary>
-        long DisposedOutsideScopeCount { get; }
+        public long DisposedOutsideScopeCount => TensorStatistics.DisposedOutsideScopeCount +
+                                                 PackedSequenceStatistics.DisposedOutsideScopeCount;
         /// <summary>
-        /// The number of disposables that were created on this thread and were captured by a DisposeScope.
+        /// The number of Tensors and PackedSequence instances that were created on this thread and were captured
+        /// by a DisposeScope.
         /// </summary>
-        long CreatedInScopeCount { get; }
+        public long CreatedInScopeCount => TensorStatistics.CreatedInScopeCount +
+                                           PackedSequenceStatistics.CreatedInScopeCount;
+
         /// <summary>
-        /// The number of disposables that were disposed on this thread and were disposed while in a DisposeScope.
+        /// The number of Tensors and PackedSequence instances that were disposed on this thread and were disposed
+        /// while in a DisposeScope.
         /// </summary>
-        long DisposedInScopeCount { get; }
+        public long DisposedInScopeCount => TensorStatistics.DisposedInScopeCount +
+                                            PackedSequenceStatistics.DisposedInScopeCount;
+
         /// <summary>
-        /// The number of disposables that were created on this thread outside a DisposeScope, and then
-        /// eventually were attached to one.
+        /// The number of Tensors and PackedSequence instances that were created on this thread outside a DisposeScope,
+        /// and then eventually were attached to one.
         /// </summary>
-        long AttachedToScopeCount { get; }
+        public long AttachedToScopeCount=> TensorStatistics.AttachedToScopeCount +
+                                           PackedSequenceStatistics.AttachedToScopeCount;
+
         /// <summary>
-        /// Number of disposables that were once included in the scope, but were subsequently detached.
+        /// Number of Tensors and PackedSequence instances that were once included in a DisposeScope, but were
+        /// subsequently detached.
         /// </summary>
-        long DetachedFromScopeCount { get; }
+        public long DetachedFromScopeCount=> TensorStatistics.DetachedFromScopeCount +
+                                             PackedSequenceStatistics.DetachedFromScopeCount;
+
         /// <summary>
-        /// The number of disposables that are currently live on the current thread.
+        /// Exact number of Tensors and PackedSequence instances that are still live. Is the difference of all
+        /// created objects minus all disposed objects.
         /// </summary>
-        long ThreadTotalLiveCount { get; }
+        public long ThreadTotalLiveCount => TensorStatistics.ThreadTotalLiveCount +
+                                            PackedSequenceStatistics.ThreadTotalLiveCount;
+
         /// <summary>
-        /// Resets the counts for the current thread. See ThreadTotalLiveCount etc. Mainly used in tests to make sure
-        /// we get a clean slate on the thread.
+        /// Resets the counts for the current thread. See ThreadTotalLiveCount etc. Mainly used in tests and memory
+        /// leak debugging to make sure we get a clean slate on the thread.
         /// </summary>
-        void Reset();
+        public void Reset()
+        {
+            TensorStatistics.Reset();
+            PackedSequenceStatistics.Reset();
+        }
         /// <summary>
         /// A debug printout of all the properties and their values, suitable for a log or console output
         /// </summary>
         /// <returns></returns>
-        string ToString();
-    }
-
-    /// <summary>
-    /// Keeps track of the combined Tensor and PackedSequence statistics for the current thread. Can be queried to figure out performance/memory issues.
-    /// </summary>
-    public class ThreadDisposeScopeStatistics: ILifetimeStatistics
-    {
-        public long CreatedOutsideScopeCount => _TensorStatistics.CreatedOutsideScopeCount +
-                                                _PackedSequenceStatistics.CreatedOutsideScopeCount;
-
-        public long DisposedOutsideScopeCount => _TensorStatistics.DisposedOutsideScopeCount +
-                                                _PackedSequenceStatistics.DisposedOutsideScopeCount;
-        public long CreatedInScopeCount => _TensorStatistics.CreatedInScopeCount +
-                                           _PackedSequenceStatistics.CreatedInScopeCount;
-
-        public long DisposedInScopeCount => _TensorStatistics.DisposedInScopeCount +
-                                            _PackedSequenceStatistics.DisposedInScopeCount;
-
-        public long AttachedToScopeCount=> _TensorStatistics.AttachedToScopeCount +
-                                             _PackedSequenceStatistics.AttachedToScopeCount;
-
-        public long DetachedFromScopeCount=> _TensorStatistics.DetachedFromScopeCount +
-                                             _PackedSequenceStatistics.DetachedFromScopeCount;
-
-        public long ThreadTotalLiveCount => _TensorStatistics.ThreadTotalLiveCount +
-                                            _PackedSequenceStatistics.ThreadTotalLiveCount;
-
-        public void Reset()
-        {
-            _TensorStatistics.Reset();
-            _PackedSequenceStatistics.Reset();
-        }
-
         public override string ToString()
         {
-            return LifetimeStatisticsUtil.DebugString(this);
+            var sb = new StringBuilder();
+            sb.Append("ThreadTotalLiveCount: " + ThreadTotalLiveCount);
+            sb.Append("; CreatedOutsideScopeCount: " + CreatedOutsideScopeCount);
+            sb.Append("; DisposedOutsideScopeCount: " + DisposedOutsideScopeCount);
+            sb.Append("; CreatedInScopeCount: " + CreatedInScopeCount);
+            sb.Append("; DisposedInScopeCount: " + DisposedInScopeCount);
+            sb.Append("; AttachedToScopeCount: " + AttachedToScopeCount);
+            sb.Append("; DetachedFromScopeCount: " + DetachedFromScopeCount);
+            return sb.ToString();
         }
         /// <summary>
         /// Keeps track of the Tensor statistics for the current thread. Can be queried to figure out performance/memory issues.
         /// </summary>
-        public ILifetimeStatistics TensorStatistics => _TensorStatistics;
-        internal LifetimeStatistics _TensorStatistics { get; set; } = new LifetimeStatistics();
+        public LifetimeStatistics TensorStatistics { get; } = new LifetimeStatistics();
         /// <summary>
         /// Keeps track of the PackedSequence statistics for the current thread. Can be queried to figure out performance/memory issues.
         /// </summary>
-        public ILifetimeStatistics PackedSequenceStatistics => _PackedSequenceStatistics;
-        internal LifetimeStatistics _PackedSequenceStatistics { get; set; } = new LifetimeStatistics();
+        public LifetimeStatistics PackedSequenceStatistics { get; } = new LifetimeStatistics();
     }
 
-    public class LifetimeStatistics : ILifetimeStatistics
+    public class LifetimeStatistics
     {
+        /// <summary>
+        /// The number of disposables that were created on this thread, but weren't captured by a DisposeScope.
+        /// </summary>
         public long CreatedOutsideScopeCount { get; internal set; }
+        /// <summary>
+        /// The number of disposables that were Disposed on this thread, but weren't captured by a DisposeScope.
+        /// </summary>
         public long DisposedOutsideScopeCount { get; internal set; }
+        /// <summary>
+        /// The number of disposables that were created on this thread and were captured by a DisposeScope.
+        /// </summary>
         public long CreatedInScopeCount { get; internal set; }
+        /// <summary>
+        /// The number of disposables that were disposed on this thread and were disposed while in a DisposeScope.
+        /// </summary>
         public long DisposedInScopeCount { get; internal set; }
+        /// <summary>
+        /// The number of disposables that were created on this thread outside a DisposeScope, and then
+        /// eventually were attached to one.
+        /// </summary>
         public long AttachedToScopeCount { get; internal set; }
+        /// <summary>
+        /// Number of disposables that were once included in a DisposeScope, but were subsequently detached.
+        /// </summary>
         public long DetachedFromScopeCount { get; internal set; }
         /// <summary>
         /// Exact number of objects that are still live. Is the difference of all created objects
         /// minus all disposed objects.
         /// </summary>
-        public long ThreadTotalLiveCount => (CreatedInScopeCount - DisposedInScopeCount) + (CreatedOutsideScopeCount - DisposedOutsideScopeCount);
+        public long ThreadTotalLiveCount => (CreatedInScopeCount - DisposedInScopeCount) +
+                                            (CreatedOutsideScopeCount - DisposedOutsideScopeCount);
 
+        /// <summary>
+        /// Resets the counts for the current thread. See ThreadTotalLiveCount etc. Mainly used in tests to make sure
+        /// we get a clean slate on the thread.
+        /// </summary>
         public void Reset()
         {
             CreatedOutsideScopeCount = 0;
@@ -117,23 +139,20 @@ public void Reset()
             AttachedToScopeCount = 0;
             DetachedFromScopeCount = 0;
         }
+        /// <summary>
+        /// A debug printout of all the properties and their values, suitable for a log or console output
+        /// </summary>
+        /// <returns></returns>
         public override string ToString()
-        {
-            return LifetimeStatisticsUtil.DebugString(this);
-        }
-    }
-    static class LifetimeStatisticsUtil
-    {
-        public static string DebugString(this ILifetimeStatistics statistics)
         {
             var sb = new StringBuilder();
-            sb.Append("ThreadTotalLiveCount: " + statistics.ThreadTotalLiveCount);
-            sb.Append("; CreatedOutsideScopeCount: " + statistics.CreatedOutsideScopeCount);
-            sb.Append("; DisposedOutsideScopeCount: " + statistics.DisposedOutsideScopeCount);
-            sb.Append("; CreatedInScopeCount: " + statistics.CreatedInScopeCount);
-            sb.Append("; DisposedInScopeCount: " + statistics.DisposedInScopeCount);
-            sb.Append("; AttachedToScopeCount: " + statistics.AttachedToScopeCount);
-            sb.Append("; DetachedFromScopeCount: " + statistics.DetachedFromScopeCount);
+            sb.Append("ThreadTotalLiveCount: " + ThreadTotalLiveCount);
+            sb.Append("; CreatedOutsideScopeCount: " + CreatedOutsideScopeCount);
+            sb.Append("; DisposedOutsideScopeCount: " + DisposedOutsideScopeCount);
+            sb.Append("; CreatedInScopeCount: " + CreatedInScopeCount);
+            sb.Append("; DisposedInScopeCount: " + DisposedInScopeCount);
+            sb.Append("; AttachedToScopeCount: " + AttachedToScopeCount);
+            sb.Append("; DetachedFromScopeCount: " + DetachedFromScopeCount);
             return sb.ToString();
         }
     }

test/TorchSharpTest/TestDisposeScopesStatisticsBase.cs

@@ -39,15 +39,20 @@ protected static void AssertTotalsCounts(long createdOutside,
             long detached,
             long threadTotalLive)
         {
-            AssertStatCounts(createdOutside, disposedOutside,
-                createdIn, disposedIn,
-                attached, detached, threadTotalLive, DisposeScopeManager.Statistics);
+            var stats = DisposeScopeManager.Statistics;
+            Assert.True(createdOutside == stats.CreatedOutsideScopeCount, $"CreatedOutsideScopeCount: Expected({createdOutside})!={stats.CreatedOutsideScopeCount}");
+            Assert.True(disposedOutside == stats.DisposedOutsideScopeCount, $"DisposedOutsideScopeCount: Expected({disposedOutside})!={stats.DisposedOutsideScopeCount}");
+            Assert.True(createdIn == stats.CreatedInScopeCount, $"CreatedInScope: Expected({createdIn})!={stats.CreatedInScopeCount}");
+            Assert.True(disposedIn == stats.DisposedInScopeCount, $"DisposedInScopeCount: Expected({disposedIn})!={stats.DisposedInScopeCount}");
+            Assert.True(attached == stats.AttachedToScopeCount, $"AttachedToScopeCount: Expected({attached})!={stats.AttachedToScopeCount}");
+            Assert.True(detached == stats.DetachedFromScopeCount, $"DetachedFromScopeCount: Expected({detached})!={stats.DetachedFromScopeCount}");
+            Assert.True(threadTotalLive == stats.ThreadTotalLiveCount, $"ThreadTotalLiveCount: Expected({threadTotalLive})!={stats.ThreadTotalLiveCount}");
         }
 
         protected static void AssertStatCounts(long createdOutside, long disposedOutside,
             long createdIn, long disposedIn,
             long attached, long detached,
-            long threadTotalLive, ILifetimeStatistics stats)
+            long threadTotalLive, LifetimeStatistics stats)
         {
             Assert.True(createdOutside == stats.CreatedOutsideScopeCount, $"CreatedOutsideScopeCount: Expected({createdOutside})!={stats.CreatedOutsideScopeCount}");
             Assert.True(disposedOutside == stats.DisposedOutsideScopeCount, $"DisposedOutsideScopeCount: Expected({disposedOutside})!={stats.DisposedOutsideScopeCount}");