[Neo VM] adopt light gc from neogo

benchmarks/Neo.VM.Benchmarks/TestArray.cs

@@ -29,9 +29,7 @@ public StackItem this[int index]
             set
             {
                 if (IsReadOnly) throw new InvalidOperationException("The object is readonly.");
-                ReferenceCounter?.RemoveReference(_array[index], this);
                 _array[index] = value;
-                ReferenceCounter?.AddReference(value, this);
             }
         }
 
@@ -43,32 +41,21 @@ public StackItem this[int index]
         public override int SubItemsCount => _array.Count;
         public override StackItemType Type => StackItemType.Array;
 
-        /// <summary>
-        /// Create an array containing the specified items.
-        /// </summary>
-        /// <param name="items">The items to be included in the array.</param>
-        public TestArray(IEnumerable<StackItem>? items = null)
-            : this(null, items)
-        {
-        }
 
         /// <summary>
         /// Create an array containing the specified items. And make the array use the specified <see cref="IReferenceCounter"/>.
         /// </summary>
         /// <param name="referenceCounter">The <see cref="IReferenceCounter"/> to be used by this array.</param>
         /// <param name="items">The items to be included in the array.</param>
-        public TestArray(IReferenceCounter? referenceCounter, IEnumerable<StackItem>? items = null)
-            : base(referenceCounter)
+        public TestArray(IEnumerable<StackItem>? items = null)
+            : base()
         {
             _array = items switch
             {
                 null => new List<StackItem>(),
                 List<StackItem> list => list,
                 _ => new List<StackItem>(items)
             };
-            if (referenceCounter != null)
-                foreach (StackItem item in _array)
-                    referenceCounter.AddReference(item, this);
         }
 
         /// <summary>
@@ -79,29 +66,25 @@ public void Add(StackItem item)
         {
             if (IsReadOnly) throw new InvalidOperationException("The object is readonly.");
             _array.Add(item);
-            ReferenceCounter?.AddReference(item, this);
         }
 
         public override void Clear()
         {
             if (IsReadOnly) throw new InvalidOperationException("The object is readonly.");
-            if (ReferenceCounter != null)
-                foreach (StackItem item in _array)
-                    ReferenceCounter.RemoveReference(item, this);
             _array.Clear();
         }
 
         public override StackItem ConvertTo(StackItemType type)
         {
             if (Type == StackItemType.Array && type == StackItemType.Struct)
-                return new Struct(ReferenceCounter, new List<StackItem>(_array));
+                return new Struct(new List<StackItem>(_array));
             return base.ConvertTo(type);
         }
 
         internal sealed override StackItem DeepCopy(Dictionary<StackItem, StackItem> refMap, bool asImmutable)
         {
             if (refMap.TryGetValue(this, out StackItem? mappedItem)) return mappedItem;
-            var result = this is TestStruct ? new TestStruct(ReferenceCounter) : new TestArray(ReferenceCounter);
+            var result = this is TestStruct ? new TestStruct() : new TestArray();
             refMap.Add(this, result);
             foreach (StackItem item in _array)
                 result.Add(item.DeepCopy(refMap, asImmutable));
@@ -126,7 +109,6 @@ public IEnumerator<StackItem> GetEnumerator()
         public void RemoveAt(int index)
         {
             if (IsReadOnly) throw new InvalidOperationException("The object is readonly.");
-            ReferenceCounter?.RemoveReference(_array[index], this);
             _array.RemoveAt(index);
         }
 

benchmarks/Neo.VM.Benchmarks/TestStruct.cs

@@ -17,22 +17,14 @@ public class TestStruct : TestArray
     {
         public override StackItemType Type => StackItemType.Struct;
 
-        /// <summary>
-        /// Create a structure with the specified fields.
-        /// </summary>
-        /// <param name="fields">The fields to be included in the structure.</param>
-        public TestStruct(IEnumerable<StackItem>? fields = null)
-            : this(null, fields)
-        {
-        }
 
         /// <summary>
         /// Create a structure with the specified fields. And make the structure use the specified <see cref="IReferenceCounter"/>.
         /// </summary>
         /// <param name="referenceCounter">The <see cref="IReferenceCounter"/> to be used by this structure.</param>
         /// <param name="fields">The fields to be included in the structure.</param>
-        public TestStruct(IReferenceCounter? referenceCounter, IEnumerable<StackItem>? fields = null)
-            : base(referenceCounter, fields)
+        public TestStruct(IEnumerable<StackItem>? fields = null)
+            : base(fields)
         {
         }
 
@@ -44,7 +36,7 @@ public TestStruct(IReferenceCounter? referenceCounter, IEnumerable<StackItem>? f
         public TestStruct Clone(ExecutionEngineLimits limits)
         {
             int count = (int)(limits.MaxStackSize - 1);
-            TestStruct result = new(ReferenceCounter);
+            TestStruct result = new();
             Queue<TestStruct> queue = new();
             queue.Enqueue(result);
             queue.Enqueue(this);
@@ -58,7 +50,7 @@ public TestStruct Clone(ExecutionEngineLimits limits)
                     if (count < 0) throw new InvalidOperationException("Beyond clone limits!");
                     if (item is TestStruct sb)
                     {
-                        TestStruct sa = new(ReferenceCounter);
+                        TestStruct sa = new();
                         a.Add(sa);
                         queue.Enqueue(sa);
                         queue.Enqueue(sb);
@@ -75,7 +67,7 @@ public TestStruct Clone(ExecutionEngineLimits limits)
         public override StackItem ConvertTo(StackItemType type)
         {
             if (type == StackItemType.Array)
-                return new TestArray(ReferenceCounter, new List<StackItem>(_array));
+                return new TestArray(new List<StackItem>(_array));
             return base.ConvertTo(type);
         }
 

benchmarks/Neo.VM.Benchmarks/VMTypes/Benchmarks_Convert.cs

@@ -60,7 +60,7 @@ public IEnumerable<object[]> GetTypeConversionPairs()
 
         private Dictionary<StackItemType, List<StackItem>> CreateTestItemsByType()
         {
-            var referenceCounter = new ReferenceCounter();
+            var referenceCounter = new ReferenceCounterV2();
             var result = new Dictionary<StackItemType, List<StackItem>>();
 
             foreach (StackItemType type in Enum.GetValues(typeof(StackItemType)))
@@ -84,22 +84,22 @@ private Dictionary<StackItemType, List<StackItem>> CreateTestItemsByType()
             result[StackItemType.Buffer].Add(new Buffer(new byte[128])); // Another 128-byte buffer, all zeros
 
             // Create an array with 10 items
-            var longArray = new Array(referenceCounter);
+            var longArray = new Array();
             for (int i = 0; i < 10; i++) longArray.Add(new Integer(i));
             result[StackItemType.Array].Add(longArray);
-            result[StackItemType.Array].Add(new Array(referenceCounter) { StackItem.True, new ByteString(new byte[] { 3, 4, 5 }) });
+            result[StackItemType.Array].Add(new Array() { StackItem.True, new ByteString(new byte[] { 3, 4, 5 }) });
 
             // Create a struct with 10 items
-            var longStruct = new Struct(referenceCounter);
+            var longStruct = new Struct();
             for (int i = 0; i < 10; i++) longStruct.Add(new Integer(i * 10));
             result[StackItemType.Struct].Add(longStruct);
-            result[StackItemType.Struct].Add(new Struct(referenceCounter) { StackItem.False, new Buffer(new byte[] { 6, 7, 8 }) });
+            result[StackItemType.Struct].Add(new Struct() { StackItem.False, new Buffer(new byte[] { 6, 7, 8 }) });
 
             // Create a map with 10 items
-            var longMap = new Map(referenceCounter);
+            var longMap = new Map();
             for (int i = 0; i < 10; i++) longMap[new Integer(i)] = new ByteString(new byte[] { (byte)(i * 20) });
             result[StackItemType.Map].Add(longMap);
-            result[StackItemType.Map].Add(new Map(referenceCounter) { [new ByteString(new byte[] { 9 })] = StackItem.True });
+            result[StackItemType.Map].Add(new Map() { [new ByteString(new byte[] { 9 })] = StackItem.True });
 
             result[StackItemType.InteropInterface].Add(new InteropInterface(new object()));
             result[StackItemType.InteropInterface].Add(new InteropInterface("test string"));

benchmarks/Neo.VM.Benchmarks/VMTypes/Benchmarks_DeepCopy.cs

@@ -39,38 +39,38 @@ public class Benchmarks_DeepCopy
         [Benchmark]
         public void BenchNestedArrayDeepCopy()
         {
-            var root = new Array(new ReferenceCounter());
+            var root = new Array();
             CreateNestedArray(root, Params.Depth, Params.ElementsPerLevel);
             _ = root.DeepCopy();
         }
 
         [Benchmark]
         public void BenchNestedArrayDeepCopyWithReferenceCounter()
         {
-            var referenceCounter = new ReferenceCounter();
-            var root = new Array(referenceCounter);
-            CreateNestedArray(root, Params.Depth, Params.ElementsPerLevel, referenceCounter);
+            var referenceCounter = new ReferenceCounterV2();
+            var root = new Array();
+            CreateNestedArray(root, Params.Depth, Params.ElementsPerLevel);
             _ = root.DeepCopy();
         }
 
         [Benchmark]
         public void BenchNestedTestArrayDeepCopy()
         {
-            var root = new TestArray(new ReferenceCounter());
+            var root = new TestArray();
             CreateNestedTestArray(root, Params.Depth, Params.ElementsPerLevel);
             _ = root.DeepCopy();
         }
 
         [Benchmark]
         public void BenchNestedTestArrayDeepCopyWithReferenceCounter()
         {
-            var referenceCounter = new ReferenceCounter();
-            var root = new TestArray(referenceCounter);
-            CreateNestedTestArray(root, Params.Depth, Params.ElementsPerLevel, referenceCounter);
+            var referenceCounter = new ReferenceCounterV2();
+            var root = new TestArray();
+            CreateNestedTestArray(root, Params.Depth, Params.ElementsPerLevel);
             _ = root.DeepCopy();
         }
 
-        private static void CreateNestedArray(Array? rootArray, int depth, int elementsPerLevel = 1, IReferenceCounter? referenceCounter = null)
+        private static void CreateNestedArray(Array? rootArray, int depth, int elementsPerLevel = 1)
         {
             if (depth < 0)
             {
@@ -89,13 +89,13 @@ private static void CreateNestedArray(Array? rootArray, int depth, int elementsP
 
             for (var i = 0; i < elementsPerLevel; i++)
             {
-                var childArray = new Array(referenceCounter);
+                var childArray = new Array();
                 rootArray.Add(childArray);
-                CreateNestedArray(childArray, depth - 1, elementsPerLevel, referenceCounter);
+                CreateNestedArray(childArray, depth - 1, elementsPerLevel);
             }
         }
 
-        private static void CreateNestedTestArray(TestArray rootArray, int depth, int elementsPerLevel = 1, IReferenceCounter? referenceCounter = null)
+        private static void CreateNestedTestArray(TestArray rootArray, int depth, int elementsPerLevel = 1)
         {
             if (depth < 0)
             {
@@ -114,9 +114,9 @@ private static void CreateNestedTestArray(TestArray rootArray, int depth, int el
 
             for (var i = 0; i < elementsPerLevel; i++)
             {
-                var childArray = new TestArray(referenceCounter);
+                var childArray = new TestArray();
                 rootArray.Add(childArray);
-                CreateNestedTestArray(childArray, depth - 1, elementsPerLevel, referenceCounter);
+                CreateNestedTestArray(childArray, depth - 1, elementsPerLevel);
             }
         }
     }

src/Neo.VM/ExecutionEngine.cs

@@ -84,7 +84,7 @@ protected internal set
         /// Initializes a new instance of the <see cref="ExecutionEngine"/> class.
         /// </summary>
         /// <param name="jumpTable">The jump table to be used.</param>
-        public ExecutionEngine(JumpTable? jumpTable = null) : this(jumpTable, new ReferenceCounter(), ExecutionEngineLimits.Default)
+        public ExecutionEngine(JumpTable? jumpTable = null) : this(jumpTable, new ReferenceCounterV2(), ExecutionEngineLimits.Default)
         {
         }
 
@@ -289,8 +289,7 @@ public T Pop<T>() where T : StackItem
         /// </summary>
         protected virtual void PostExecuteInstruction(Instruction instruction)
         {
-            if (ReferenceCounter.Count < Limits.MaxStackSize) return;
-            if (ReferenceCounter.CheckZeroReferred() > Limits.MaxStackSize)
+            if (ReferenceCounter.Count > Limits.MaxStackSize)
                 throw new InvalidOperationException($"MaxStackSize exceed: {ReferenceCounter.Count}");
         }