ReferenceCounterV2

benchmarks/Neo.VM.Benchmarks/Benchmarks.ReferenceCounter.cs

@@ -0,0 +1,55 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// Benchmarks.ReferenceCounter.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using BenchmarkDotNet.Attributes;
+using Neo.Test;
+using Neo.Test.Extensions;
+using Neo.Test.Types;
+using System.Text;
+
+namespace Neo.VM.Benchmark
+{
+    public class Benchmarks_ReferenceCounter : VMJsonTestBase
+    {
+        [Benchmark]
+        public void V2()
+        {
+            Run<ReferenceCounterV2>();
+        }
+
+        [Benchmark]
+        public void V1()
+        {
+            Run<ReferenceCounter>();
+        }
+
+        private void Run<T>() where T : IReferenceCounter, new()
+        {
+            var path = Path.GetFullPath("../../../../../../../../../tests/Neo.VM.Tests/Tests");
+
+            foreach (var file in Directory.GetFiles(path, "*.json", SearchOption.AllDirectories))
+            {
+                var realFile = Path.GetFullPath(file);
+                var json = File.ReadAllText(realFile, Encoding.UTF8);
+                var ut = json.DeserializeJson<VMUT>();
+
+                try
+                {
+                    ExecuteTest<T>(ut);
+                }
+                catch (Exception ex)
+                {
+                    throw new AggregateException("Error in file: " + realFile, ex);
+                }
+            }
+        }
+    }
+}

benchmarks/Neo.VM.Benchmarks/Program.cs

@@ -19,7 +19,7 @@
 var runBenchmark = true;
 
 // Define the benchmark or execute class
-var benchmarkType = typeof(Benchmarks_PoCs);
+var benchmarkType = typeof(Benchmarks_ReferenceCounter);
 
 /*
  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

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)
         {
         }
 
@@ -94,7 +94,7 @@ protected internal set
         /// <param name="jumpTable">The jump table to be used.</param>
         /// <param name="referenceCounter">The reference counter to be used.</param>
         /// <param name="limits">Restrictions on the VM.</param>
-        protected ExecutionEngine(JumpTable? jumpTable, IReferenceCounter referenceCounter, ExecutionEngineLimits limits)
+        public ExecutionEngine(JumpTable? jumpTable, IReferenceCounter referenceCounter, ExecutionEngineLimits limits)
         {
             JumpTable = jumpTable ?? JumpTable.Default;
             Limits = limits;

src/Neo.VM/ReferenceCounterV2.cs

@@ -0,0 +1,128 @@
+// Copyright (C) 2015-2024 The Neo Project.
+//
+// ReferenceCounterV2.cs file belongs to the neo project and is free
+// software distributed under the MIT software license, see the
+// accompanying file LICENSE in the main directory of the
+// repository or http://www.opensource.org/licenses/mit-license.php
+// for more details.
+//
+// Redistribution and use in source and binary forms with or without
+// modifications are permitted.
+
+using Neo.VM.Types;
+using System;
+using System.Collections.Generic;
+
+namespace Neo.VM
+{
+    /// <summary>
+    /// Used for reference counting of objects in the VM.
+    /// </summary>
+    public sealed class ReferenceCounterV2 : IReferenceCounter
+    {
+        private readonly List<StackItem> _stack = [];
+
+        /// <summary>
+        /// Gets the count of references.
+        /// </summary>
+        public int Count => _stack.Count;
+
+        /// <summary>
+        /// Adds item to Reference Counter
+        /// </summary>
+        /// <param name="item">The item to add.</param>
+        /// <param name="count">Number of similar entries</param>
+        public void AddStackReference(StackItem item, int count = 1)
+        {
+            for (var x = 0; x < count; x++)
+            {
+                if (item is CompoundType compound && ReferenceEqualsIndexOf(item) == -1)
+                {
+                    // Add sub items only if it was not present
+
+                    foreach (var subItem in compound.SubItems)
+                    {
+                        AddStackReference(subItem);
+                    }
+                }
+
+                _stack.Add(item);
+            }
+        }
+
+        /// <summary>
+        /// Removes item from Reference Counter
+        /// </summary>
+        /// <param name="item">The item to remove.</param>
+        public void RemoveStackReference(StackItem item)
+        {
+            var indexOf = ReferenceEqualsIndexOf(item);
+
+            if (indexOf == -1)
+            {
+                throw new InvalidOperationException("Reference was not added before");
+            }
+
+            _stack.RemoveAt(indexOf);
+
+            if (item is CompoundType compound && ReferenceEqualsIndexOf(item, indexOf) == -1)
+            {
+                // Remove all the childrens only if the compound is not present
+
+                foreach (var subItem in compound.SubItems)
+                {
+                    RemoveStackReference(subItem);
+                }
+            }
+        }
+
+        private int ReferenceEqualsIndexOf(StackItem item, int index = 0)
+        {
+            // Note: List use Equals, and Struct don't allow to use it, so we iterate over the list
+
+            for (; index < _stack.Count; index++)
+            {
+                if (ReferenceEquals(_stack[index], item))
+                {
+                    return index;
+                }
+            }
+
+            return -1;
+        }
+
+        public void AddReference(StackItem item, CompoundType parent)
+        {
+            if (ReferenceEqualsIndexOf(parent) != -1)
+            {
+                // Add only if the parent is present
+
+                AddStackReference(item);
+            }
+        }
+
+        public void RemoveReference(StackItem item, CompoundType parent)
+        {
+            if (ReferenceEqualsIndexOf(parent) != -1)
+            {
+                // Remove only if the parent is present
+
+                RemoveStackReference(item);
+            }
+        }
+
+        public void AddZeroReferred(StackItem item)
+        {
+            // This version don't use this method
+        }
+
+        /// <summary>
+        /// Checks and processes items that have zero references.
+        /// </summary>
+        /// <returns>The current reference count.</returns>
+        public int CheckZeroReferred()
+        {
+            return Count;
+        }
+    }
+}

tests/Neo.VM.Tests/Types/TestEngine.cs

@@ -21,6 +21,10 @@ public class TestEngine : ExecutionEngine
 
         public TestEngine() : base(ComposeJumpTable()) { }
 
+        public TestEngine(IReferenceCounter referenceCounter) : base(ComposeJumpTable(), referenceCounter, ExecutionEngineLimits.Default)
+        {
+        }
+
         private static JumpTable ComposeJumpTable()
         {
             JumpTable jumpTable = new JumpTable();

tests/Neo.VM.Tests/UT_ReferenceCounter.cs

@@ -159,7 +159,7 @@ public void TestRemoveReferrer()
             Assert.AreEqual(3, engine.ReferenceCounter.Count);
             Assert.AreEqual(VMState.BREAK, debugger.StepInto());
             Assert.AreEqual(2, engine.ReferenceCounter.Count);
-            Assert.AreEqual(VMState.HALT, debugger.Execute());
+            Assert.AreEqual(VMState.HALT, debugger.StepInto());
             Assert.AreEqual(1, engine.ReferenceCounter.Count);
         }
 
@@ -259,5 +259,24 @@ public void TestInvalidReferenceStackItem()
             arr.Add(arr2);
             Assert.AreEqual(11, reference.Count);
         }
+
+        [TestMethod]
+        public void TestDup()
+        {
+            using ScriptBuilder sb = new();
+            sb.Emit(OpCode.PUSH1);
+            sb.Emit(OpCode.DUP);
+
+            using ExecutionEngine engine = new();
+            engine.LoadScript(sb.ToArray());
+            Assert.AreEqual(0, engine.ReferenceCounter.Count);
+            engine.ExecuteNext();
+            Assert.AreEqual(1, engine.ReferenceCounter.Count);
+            engine.ExecuteNext();
+            Assert.AreEqual(2, engine.ReferenceCounter.Count);
+            engine.ExecuteNext();
+            Assert.AreEqual(2, engine.ReferenceCounter.Count);
+            Assert.AreEqual(VMState.HALT, engine.Execute());
+        }
     }
 }