11949367936

Committed 21 Nov 2024 08:27AM UTC coverage: 55.566% (-0.001%) from 55.567%

Build # 11949367936

Build Type

Pull #3590

github

Committed by

web-flow

Commit Message

Merge 0cdd74629 into a6fd680dc

Pull Request Pull Request #3590: [Core VM] optmize the vm

Run Details

5903 of 9160 branches covered (64.44%)

Branch coverage included in aggregate %.

3 of 3 new or added lines in 1 file covered. (100.0%)

1 existing line in 1 file now uncovered.

21933 of 40935 relevant lines covered (53.58%)

84642.92 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.75

/src/Neo.VM/ExecutionEngine.cs

// Copyright (C) 2015-2024 The Neo Project.
//
// ExecutionEngine.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;
using System.Runtime.CompilerServices;

namespace Neo.VM
{
    /// <summary>
    /// Represents the VM used to execute the script.
    /// </summary>
    public class ExecutionEngine : IDisposable
    {
        private VMState state = VMState.BREAK;
        internal bool isJumping = false;

        public JumpTable JumpTable { get; }

        /// <summary>
        /// Restrictions on the VM.
        /// </summary>
        public ExecutionEngineLimits Limits { get; }

        /// <summary>
        /// Used for reference counting of objects in the VM.
        /// </summary>
        public IReferenceCounter ReferenceCounter { get; }

        /// <summary>
        /// The invocation stack of the VM.
        /// </summary>
        public Stack<ExecutionContext> InvocationStack { get; } = new Stack<ExecutionContext>();

        /// <summary>
        /// The top frame of the invocation stack.
        /// </summary>
        public ExecutionContext? CurrentContext { get; private set; }

        /// <summary>
        /// The bottom frame of the invocation stack.
        /// </summary>
        public ExecutionContext? EntryContext { get; private set; }

        /// <summary>
        /// The stack to store the return values.
        /// </summary>
        public EvaluationStack ResultStack { get; }

        /// <summary>
        /// The VM object representing the uncaught exception.
        /// </summary>
        public StackItem? UncaughtException { get; internal set; }

        /// <summary>
        /// The current state of the VM.
        /// </summary>
        public VMState State
        {
            get
            {
                return state;
            }
            protected internal set
            {
                if (state != value)
                {
                    state = value;
                    OnStateChanged();
                }
            }
        }

        /// <summary>
        /// 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)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ExecutionEngine"/> class with the specified <see cref="VM.IReferenceCounter"/> and <see cref="ExecutionEngineLimits"/>.
        /// </summary>
        /// <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)
        {
            JumpTable = jumpTable ?? JumpTable.Default;
            Limits = limits;
            ReferenceCounter = referenceCounter;
            ResultStack = new EvaluationStack(referenceCounter);
        }

        public virtual void Dispose()
        {
            InvocationStack.Clear();
        }

        /// <summary>
        /// Start execution of the VM.
        /// </summary>
        /// <returns></returns>
        public virtual VMState Execute()
        {
            if (State == VMState.BREAK)
                State = VMState.NONE;
            while (State != VMState.HALT && State != VMState.FAULT)
                ExecuteNext();
            return State;
        }

        /// <summary>
        /// Execute the next instruction.
        /// </summary>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        protected internal void ExecuteNext()
        {
            if (InvocationStack.Count == 0)
            {
                State = VMState.HALT;
            }
            else
            {
                try
                {
                    ExecutionContext context = CurrentContext!;
                    Instruction instruction = context.CurrentInstruction ?? Instruction.RET;
                    PreExecuteInstruction(instruction);
#if VMPERF
                    Console.WriteLine("op:["
                                      + this.CurrentContext.InstructionPointer.ToString("X04")
                                      + "]"
                                      + this.CurrentContext.CurrentInstruction?.OpCode
                                      + " "
                                      + this.CurrentContext.EvaluationStack);
#endif
                    try
                    {
                        JumpTable[instruction.OpCode](this, instruction);
                    }
                    catch (CatchableException ex) when (Limits.CatchEngineExceptions)
                    {
                        JumpTable.ExecuteThrow(this, ex.Message);
                    }
                    PostExecuteInstruction(instruction);
                    if (!isJumping) context.MoveNext();
                    isJumping = false;
                }
                catch (Exception e)
                {
                    OnFault(e);
                }
            }
        }

        /// <summary>
        /// Loads the specified context into the invocation stack.
        /// </summary>
        /// <param name="context">The context to load.</param>
        public virtual void LoadContext(ExecutionContext context)
        {
            if (InvocationStack.Count >= Limits.MaxInvocationStackSize)
                throw new InvalidOperationException($"MaxInvocationStackSize exceed: {InvocationStack.Count}");
            InvocationStack.Push(context);
            if (EntryContext is null) EntryContext = context;
            CurrentContext = context;
        }

        /// <summary>
        /// Called when a context is unloaded.
        /// </summary>
        /// <param name="context">The context being unloaded.</param>
        internal virtual void UnloadContext(ExecutionContext context)
        {
            if (InvocationStack.Count == 0)
            {
                CurrentContext = null;
                EntryContext = null;
            }
            else
            {
                CurrentContext = InvocationStack.Peek();
            }
            if (context.StaticFields != null && context.StaticFields != CurrentContext?.StaticFields)
            {
                context.StaticFields.ClearReferences();
            }
            context.LocalVariables?.ClearReferences();
            context.Arguments?.ClearReferences();
        }

        /// <summary>
        /// Create a new context with the specified script without loading.
        /// </summary>
        /// <param name="script">The script used to create the context.</param>
        /// <param name="rvcount">The number of values that the context should return when it is unloaded.</param>
        /// <param name="initialPosition">The pointer indicating the current instruction.</param>
        /// <returns>The created context.</returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        protected ExecutionContext CreateContext(Script script, int rvcount, int initialPosition)
        {
            return new ExecutionContext(script, rvcount, ReferenceCounter)
            {
                InstructionPointer = initialPosition
            };
        }

        /// <summary>
        /// Create a new context with the specified script and load it.
        /// </summary>
        /// <param name="script">The script used to create the context.</param>
        /// <param name="rvcount">The number of values that the context should return when it is unloaded.</param>
        /// <param name="initialPosition">The pointer indicating the current instruction.</param>
        /// <returns>The created context.</returns>
        public ExecutionContext LoadScript(Script script, int rvcount = -1, int initialPosition = 0)
        {
            ExecutionContext context = CreateContext(script, rvcount, initialPosition);
            LoadContext(context);
            return context;
        }

        /// <summary>
        /// Called when an exception that cannot be caught by the VM is thrown.
        /// </summary>
        /// <param name="ex">The exception that caused the <see cref="VMState.FAULT"/> state.</param>
        protected virtual void OnFault(Exception ex)
        {
            State = VMState.FAULT;

#if VMPERF
            if (ex != null)
            {
                Console.Error.WriteLine(ex);
            }
#endif
        }

        /// <summary>
        /// Called when the state of the VM changed.
        /// </summary>
        protected virtual void OnStateChanged()
        {
        }

        /// <summary>
        /// Returns the item at the specified index from the top of the current stack without removing it.
        /// </summary>
        /// <param name="index">The index of the object from the top of the stack.</param>
        /// <returns>The item at the specified index.</returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public StackItem Peek(int index = 0)
        {
            return CurrentContext!.EvaluationStack.Peek(index);
        }

        /// <summary>
        /// Removes and returns the item at the top of the current stack.
        /// </summary>
        /// <returns>The item removed from the top of the stack.</returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public StackItem Pop()
        {
            return CurrentContext!.EvaluationStack.Pop();
        }

        /// <summary>
        /// Removes and returns the item at the top of the current stack and convert it to the specified type.
        /// </summary>
        /// <typeparam name="T">The type to convert to.</typeparam>
        /// <returns>The item removed from the top of the stack.</returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public T Pop<T>() where T : StackItem
        {
            return CurrentContext!.EvaluationStack.Pop<T>();
        }

        /// <summary>
        /// Called after an instruction is executed.
        /// </summary>
        protected virtual void PostExecuteInstruction(Instruction instruction)
        {
            if (ReferenceCounter.Count < Limits.MaxStackSize) return;
            if (ReferenceCounter.CheckZeroReferred() > Limits.MaxStackSize)
                throw new InvalidOperationException($"MaxStackSize exceed: {ReferenceCounter.Count}/{Limits.MaxStackSize}");
        }

        /// <summary>
        /// Called before an instruction is executed.
        /// </summary>
        protected virtual void PreExecuteInstruction(Instruction instruction) { }

        /// <summary>
        /// Pushes an item onto the top of the current stack.
        /// </summary>
        /// <param name="item">The item to be pushed.</param>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void Push(StackItem item)
        {
            CurrentContext!.EvaluationStack.Push(item);
        }
    }
}

1	// Copyright (C) 2015-2024 The Neo Project.
2	//
3	// ExecutionEngine.cs file belongs to the neo project and is free
4	// software distributed under the MIT software license, see the
5	// accompanying file LICENSE in the main directory of the
6	// repository or http://www.opensource.org/licenses/mit-license.php
7	// for more details.
8	//
9	// Redistribution and use in source and binary forms with or without
10	// modifications are permitted.
11
12	using Neo.VM.Types;
13	using System;
14	using System.Collections.Generic;
15	using System.Runtime.CompilerServices;
16
17	namespace Neo.VM
18	{
19	/// <summary>
20	/// Represents the VM used to execute the script.
21	/// </summary>
22	public class ExecutionEngine : IDisposable
23	{
24	private VMState state = VMState.BREAK;	1,929✔
25	internal bool isJumping = false;	1,929✔
26
27	public JumpTable JumpTable { get; }	99,739✔
28
29	/// <summary>
30	/// Restrictions on the VM.
31	/// </summary>
32	public ExecutionEngineLimits Limits { get; }	121,008✔
33
34	/// <summary>
35	/// Used for reference counting of objects in the VM.
36	/// </summary>
37	public IReferenceCounter ReferenceCounter { get; }	106,726✔
38
39	/// <summary>
40	/// The invocation stack of the VM.
41	/// </summary>
42	public Stack<ExecutionContext> InvocationStack { get; } = new Stack<ExecutionContext>();	206,291✔
43
44	/// <summary>
45	/// The top frame of the invocation stack.
46	/// </summary>
47	public ExecutionContext? CurrentContext { get; private set; }	345,209✔
48
49	/// <summary>
50	/// The bottom frame of the invocation stack.
51	/// </summary>
52	public ExecutionContext? EntryContext { get; private set; }	6,738✔
53
54	/// <summary>
55	/// The stack to store the return values.
56	/// </summary>
57	public EvaluationStack ResultStack { get; }	3,586✔
58
59	/// <summary>
60	/// The VM object representing the uncaught exception.
61	/// </summary>
62	public StackItem? UncaughtException { get; internal set; }	1,525✔
63
64	/// <summary>
65	/// The current state of the VM.
66	/// </summary>
67	public VMState State
68	{
69	get
70	{	211,357✔
71	return state;	211,357✔
72	}	211,357✔
73	protected internal set
74	{	3,268✔
75	if (state != value)	3,268✔
76	{	3,268✔
77	state = value;	3,268✔
78	OnStateChanged();	3,268✔
79	}	3,268✔
80	}	3,268✔
81	}
82
83	/// <summary>
84	/// Initializes a new instance of the <see cref="ExecutionEngine"/> class.
85	/// </summary>
86	/// <param name="jumpTable">The jump table to be used.</param>
87	public ExecutionEngine(JumpTable? jumpTable = null) : this(jumpTable, new ReferenceCounter(), ExecutionEngineLimits.Default)	1,929✔
88	{	1,929✔
89	}	1,929✔
90
91	/// <summary>
92	/// Initializes a new instance of the <see cref="ExecutionEngine"/> class with the specified <see cref="VM.IReferenceCounter"/> and <see cref="ExecutionEngineLimits"/>.
93	/// </summary>
94	/// <param name="jumpTable">The jump table to be used.</param>
95	/// <param name="referenceCounter">The reference counter to be used.</param>
96	/// <param name="limits">Restrictions on the VM.</param>
97	protected ExecutionEngine(JumpTable? jumpTable, IReferenceCounter referenceCounter, ExecutionEngineLimits limits)	1,929✔
98	{	1,929✔
99	JumpTable = jumpTable ?? JumpTable.Default;	1,929✔
100	Limits = limits;	1,929✔
101	ReferenceCounter = referenceCounter;	1,929✔
102	ResultStack = new EvaluationStack(referenceCounter);	1,929✔
103	}	1,929✔
104
105	public virtual void Dispose()
106	{	1,831✔
107	InvocationStack.Clear();	1,831✔
108	}	1,831✔
109
110	/// <summary>
111	/// Start execution of the VM.
112	/// </summary>
113	/// <returns></returns>
114	public virtual VMState Execute()
115	{	1,105✔
116	if (State == VMState.BREAK)	1,105✔
117	State = VMState.NONE;	1,105✔
118	while (State != VMState.HALT && State != VMState.FAULT)	12,057✔
119	ExecuteNext();	10,952✔
120	return State;	1,105✔
121	}	1,105✔
122
123	/// <summary>
124	/// Execute the next instruction.
125	/// </summary>
126	[MethodImpl(MethodImplOptions.AggressiveInlining)]
127	protected internal void ExecuteNext()
128	{	99,741✔
129	if (InvocationStack.Count == 0)	99,741✔
130	{	1✔
131	State = VMState.HALT;	1✔
132	}	1✔
133	else
134	{	99,740✔
135	try
136	{	99,740✔
137	ExecutionContext context = CurrentContext!;	99,740✔
138	Instruction instruction = context.CurrentInstruction ?? Instruction.RET;	99,740✔
139	PreExecuteInstruction(instruction);	99,731✔
140	#if VMPERF
141	Console.WriteLine("op:["
142	+ this.CurrentContext.InstructionPointer.ToString("X04")
143	+ "]"
144	+ this.CurrentContext.CurrentInstruction?.OpCode
145	+ " "
146	+ this.CurrentContext.EvaluationStack);
147	#endif
148	try
149	{	99,731✔
150	JumpTable[instruction.OpCode](this, instruction);	99,731✔
151	}	99,380✔
152	catch (CatchableException ex) when (Limits.CatchEngineExceptions)	7✔
153	{	7✔
154	JumpTable.ExecuteThrow(this, ex.Message);	7✔
UNCOV 155	}	×
156	PostExecuteInstruction(instruction);	99,380✔
157	if (!isJumping) context.MoveNext();	188,643✔
158	isJumping = false;	99,376✔
159	}	99,376✔
160	catch (Exception e)	364✔
161	{	364✔
162	OnFault(e);	364✔
163	}	364✔
164	}	99,740✔
165	}	99,741✔
166
167	/// <summary>
168	/// Loads the specified context into the invocation stack.
169	/// </summary>
170	/// <param name="context">The context to load.</param>
171	public virtual void LoadContext(ExecutionContext context)
172	{	3,399✔
173	if (InvocationStack.Count >= Limits.MaxInvocationStackSize)	3,399✔
174	throw new InvalidOperationException($"MaxInvocationStackSize exceed: {InvocationStack.Count}");	1✔
175	InvocationStack.Push(context);	3,398✔
176	if (EntryContext is null) EntryContext = context;	5,299✔
177	CurrentContext = context;	3,398✔
178	}	3,398✔
179
180	/// <summary>
181	/// Called when a context is unloaded.
182	/// </summary>
183	/// <param name="context">The context being unloaded.</param>
184	internal virtual void UnloadContext(ExecutionContext context)
185	{	1,861✔
186	if (InvocationStack.Count == 0)	1,861✔
187	{	1,431✔
188	CurrentContext = null;	1,431✔
189	EntryContext = null;	1,431✔
190	}	1,431✔
191	else
192	{	430✔
193	CurrentContext = InvocationStack.Peek();	430✔
194	}	430✔
195	if (context.StaticFields != null && context.StaticFields != CurrentContext?.StaticFields)	1,861!
196	{	29✔
197	context.StaticFields.ClearReferences();	29✔
198	}	29✔
199	context.LocalVariables?.ClearReferences();	1,861✔
200	context.Arguments?.ClearReferences();	1,861✔
201	}	1,861✔
202
203	/// <summary>
204	/// Create a new context with the specified script without loading.
205	/// </summary>
206	/// <param name="script">The script used to create the context.</param>
207	/// <param name="rvcount">The number of values that the context should return when it is unloaded.</param>
208	/// <param name="initialPosition">The pointer indicating the current instruction.</param>
209	/// <returns>The created context.</returns>
210	[MethodImpl(MethodImplOptions.AggressiveInlining)]
211	protected ExecutionContext CreateContext(Script script, int rvcount, int initialPosition)
212	{	2,363✔
213	return new ExecutionContext(script, rvcount, ReferenceCounter)	2,363✔
214	{	2,363✔
215	InstructionPointer = initialPosition	2,363✔
216	};	2,363✔
217	}	2,363✔
218
219	/// <summary>
220	/// Create a new context with the specified script and load it.
221	/// </summary>
222	/// <param name="script">The script used to create the context.</param>
223	/// <param name="rvcount">The number of values that the context should return when it is unloaded.</param>
224	/// <param name="initialPosition">The pointer indicating the current instruction.</param>
225	/// <returns>The created context.</returns>
226	public ExecutionContext LoadScript(Script script, int rvcount = -1, int initialPosition = 0)
227	{	749✔
228	ExecutionContext context = CreateContext(script, rvcount, initialPosition);	749✔
229	LoadContext(context);	749✔
230	return context;	749✔
231	}	749✔
232
233	/// <summary>
234	/// Called when an exception that cannot be caught by the VM is thrown.
235	/// </summary>
236	/// <param name="ex">The exception that caused the <see cref="VMState.FAULT"/> state.</param>
237	protected virtual void OnFault(Exception ex)
238	{	404✔
239	State = VMState.FAULT;	404✔
240
241	#if VMPERF
242	if (ex != null)
243	{
244	Console.Error.WriteLine(ex);
245	}
246	#endif
247	}	404✔
248
249	/// <summary>
250	/// Called when the state of the VM changed.
251	/// </summary>
252	protected virtual void OnStateChanged()
253	{	3,268✔
254	}	3,268✔
255
256	/// <summary>
257	/// Returns the item at the specified index from the top of the current stack without removing it.
258	/// </summary>
259	/// <param name="index">The index of the object from the top of the stack.</param>
260	/// <returns>The item at the specified index.</returns>
261	[MethodImpl(MethodImplOptions.AggressiveInlining)]
262	public StackItem Peek(int index = 0)
263	{	1,115✔
264	return CurrentContext!.EvaluationStack.Peek(index);	1,115✔
265	}	1,111✔
266
267	/// <summary>
268	/// Removes and returns the item at the top of the current stack.
269	/// </summary>
270	/// <returns>The item removed from the top of the stack.</returns>
271	[MethodImpl(MethodImplOptions.AggressiveInlining)]
272	public StackItem Pop()
273	{	67,351✔
274	return CurrentContext!.EvaluationStack.Pop();	67,351✔
275	}	67,277✔
276
277	/// <summary>
278	/// Removes and returns the item at the top of the current stack and convert it to the specified type.
279	/// </summary>
280	/// <typeparam name="T">The type to convert to.</typeparam>
281	/// <returns>The item removed from the top of the stack.</returns>
282	[MethodImpl(MethodImplOptions.AggressiveInlining)]
283	public T Pop<T>() where T : StackItem
284	{	115✔
285	return CurrentContext!.EvaluationStack.Pop<T>();	115✔
286	}	98✔
287
288	/// <summary>
289	/// Called after an instruction is executed.
290	/// </summary>
291	protected virtual void PostExecuteInstruction(Instruction instruction)
292	{	99,380✔
293	if (ReferenceCounter.Count < Limits.MaxStackSize) return;	198,745✔
294	if (ReferenceCounter.CheckZeroReferred() > Limits.MaxStackSize)	15✔
295	throw new InvalidOperationException($"MaxStackSize exceed: {ReferenceCounter.Count}/{Limits.MaxStackSize}");	4✔
296	}	99,376✔
297
298	/// <summary>
299	/// Called before an instruction is executed.
300	/// </summary>
301	protected virtual void PreExecuteInstruction(Instruction instruction) { }	185,732✔
302
303	/// <summary>
304	/// Pushes an item onto the top of the current stack.
305	/// </summary>
306	/// <param name="item">The item to be pushed.</param>
307	[MethodImpl(MethodImplOptions.AggressiveInlining)]
308	public void Push(StackItem item)
309	{	76,056✔
310	CurrentContext!.EvaluationStack.Push(item);	76,056✔
311	}	76,056✔
312	}
313	}

neo-project / neo / 11949367936

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous