Merge pull request #52 from Akeit0/optimize

Large Optimization

Author: nuskey8

src/Lua/CodeAnalysis/Compilation/FunctionCompilationContext.cs

@@ -65,6 +65,11 @@ internal static FunctionCompilationContext Create(ScopeCompilationContext? paren
     FastListCore<BreakDescription> breakQueue;
     FastListCore<GotoDescription> gotoQueue;
 
+    /// <summary>
+    /// Maximum local stack size
+    /// </summary>
+    public byte MaxStackPosition { get; set; }
+
     /// <summary>
     /// Chunk name (for debug)
     /// </summary>
@@ -415,6 +420,7 @@ public Chunk ToChunk()
             UpValues = upvalues.AsSpan().ToArray(),
             Functions = functions.AsSpan().ToArray(),
             ParameterCount = ParameterCount,
+            MaxStackPosition = MaxStackPosition,
         };
 
         foreach (var function in functions.AsSpan())
@@ -444,6 +450,7 @@ public void Reset()
         LoopLevel = 0;
         ParameterCount = 0;
         HasVariableArguments = false;
+        MaxStackPosition = 0;
     }
 
     /// <summary>

src/Lua/CodeAnalysis/Compilation/LuaCompiler.cs

@@ -619,8 +619,16 @@ public bool VisitFunctionDeclarationStatementNode(FunctionDeclarationStatementNo
         // push closure instruction
         context.PushInstruction(Instruction.Closure(context.StackPosition, funcIndex), node.Position, true);
 
-        // assign global variable
-        context.PushInstruction(Instruction.SetTabUp(0, (ushort)(index + 256), (ushort)(context.StackPosition - 1)), node.Position);
+        if (context.TryGetLocalVariableInThisScope(node.Name, out var variable))
+        {
+            // assign local variable
+            context.PushInstruction(Instruction.Move(variable.RegisterIndex, (ushort)(context.StackPosition - 1)), node.Position, true);
+        }
+        else
+        {
+            // assign global variable
+            context.PushInstruction(Instruction.SetTabUp(0, (ushort)(index + 256), (ushort)(context.StackPosition - 1)), node.Position);
+        }
 
         return true;
     }

src/Lua/CodeAnalysis/Compilation/ScopeCompilationContext.cs

@@ -79,6 +79,7 @@ public void PushInstruction(in Instruction instruction, SourcePosition position,
         {
             StackPosition++;
         }
+        Function.MaxStackPosition = Math.Max(Function.MaxStackPosition, StackPosition);
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]

src/Lua/Exceptions.cs

@@ -4,7 +4,16 @@
 
 namespace Lua;
 
-public class LuaException(string message) : Exception(message);
+public class LuaException : Exception
+{
+    protected LuaException(Exception innerException) : base(innerException.Message, innerException)
+    {
+    }
+
+    public LuaException(string message) : base(message)
+    {
+    }
+}
 
 public class LuaParseException(string? chunkName, SourcePosition position, string message) : LuaException(message)
 {
@@ -44,9 +53,27 @@ public static void BreakNotInsideALoop(string? chunkName, SourcePosition positio
     public override string Message => $"{ChunkName}:{(Position == null ? "" : $"{Position.Value}:")} {base.Message}";
 }
 
-public class LuaRuntimeException(Traceback traceback, string message) : LuaException(message)
+public class LuaRuntimeException : LuaException
 {
-    public Traceback LuaTraceback { get; } = traceback;
+    public LuaRuntimeException(Traceback traceback, Exception innerException) : base(innerException)
+    {
+        LuaTraceback = traceback;
+    }
+
+    public LuaRuntimeException(Traceback traceback, string message) : base(message)
+    {
+        LuaTraceback = traceback;
+    }
+
+    public LuaRuntimeException(Traceback traceback, LuaValue errorObject): base(errorObject.ToString())
+    {
+        LuaTraceback = traceback;
+        ErrorObject = errorObject;
+    }
+
+    public Traceback LuaTraceback { get; }
+
+    public LuaValue? ErrorObject { get; }
 
     public static void AttemptInvalidOperation(Traceback traceback, string op, LuaValue a, LuaValue b)
     {

src/Lua/Internal/FastStackCore.cs

@@ -16,7 +16,7 @@ public struct FastStackCore<T>
     public readonly ReadOnlySpan<T> AsSpan()
     {
         if (array == null) return [];
-        return array.AsSpan(0, tail);
+        return array.AsSpan(0, tail)!;
     }
 
     public readonly Span<T?> GetBuffer()
@@ -33,15 +33,14 @@ public readonly T? this[int index]
         }
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void Push(in T item)
     {
         array ??= new T[InitialCapacity];
 
         if (tail == array.Length)
         {
-            var newArray = new T[tail * 2];
-            Array.Copy(array, newArray, tail);
-            array = newArray;
+            Array.Resize(ref array, tail * 2);
         }
 
         array[tail] = item;
@@ -64,9 +63,21 @@ public bool TryPop(out T value)
         return true;
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal bool TryPop()
+    {
+        if (tail == 0)
+        {
+            return false;
+        }
+        array[--tail] = default;
+
+        return true;
+    }
+
     public T Pop()
     {
-        if (!TryPop(out var result)) throw new InvalidOperationException("Empty stack");
+        if (!TryPop(out var result)) ThrowForEmptyStack();
         return result;
     }
 
@@ -85,7 +96,7 @@ public bool TryPeek(out T value)
 
     public T Peek()
     {
-        if (!TryPeek(out var result)) throw new InvalidOperationException();
+        if (!TryPeek(out var result)) ThrowForEmptyStack();
         return result;
     }
 
@@ -119,4 +130,9 @@ public void Clear()
         array.AsSpan(0, tail).Clear();
         tail = 0;
     }
-}
+    
+    void ThrowForEmptyStack()
+    {
+        throw new InvalidOperationException("Empty stack");
+    }
+}

src/Lua/Internal/LuaValueArrayPool.cs

@@ -0,0 +1,73 @@
+namespace Lua.Internal;
+
+internal static class LuaValueArrayPool
+{
+    static FastStackCore<LuaValue[]> poolOf1024;
+    static FastStackCore<LuaValue[]> poolOf1;
+
+    static readonly object lockObject = new();
+
+
+    public static LuaValue[] Rent1024()
+    {
+        lock (lockObject)
+        {
+            if (poolOf1024.Count > 0)
+            {
+                return poolOf1024.Pop();
+            }
+
+            return new LuaValue[1024];
+        }
+    }
+
+    public static LuaValue[] Rent1()
+    {
+        lock (lockObject)
+        {
+            if (poolOf1.Count > 0)
+            {
+                return poolOf1.Pop();
+            }
+
+            return new LuaValue[1];
+        }
+    }
+
+    public static void Return1024(LuaValue[] array, bool clear = false)
+    {
+        if (array.Length != 1024)
+        {
+            ThrowInvalidArraySize(array.Length, 1024);
+        }
+
+        if (clear)
+        {
+            array.AsSpan().Clear();
+        }
+        lock (lockObject)
+        {
+            poolOf1024.Push(array);
+        }
+    }
+
+
+    public static void Return1(LuaValue[] array)
+    {
+        if (array.Length != 1)
+        {
+            ThrowInvalidArraySize(array.Length, 1);
+        }
+
+        array[0] = LuaValue.Nil;
+        lock (lockObject)
+        {
+            poolOf1.Push(array);
+        }
+    }
+
+    static void ThrowInvalidArraySize(int size, int expectedSize)
+    {
+        throw new InvalidOperationException($"Invalid array size: {size}, expected: {expectedSize}");
+    }
+}