Testing : IL-EVM aot-Precompiler mode

src/Nethermind/Directory.Packages.props

@@ -77,6 +77,7 @@
     <PackageVersion Include="RocksDB" Version="[9.7.3.54622]" />
     <PackageVersion Include="SCrypt" Version="2.0.0.2" />
     <PackageVersion Include="Shouldly" Version="4.2.1" />
+    <PackageVersion Include="Sigil" Version="5.0.0" />
     <PackageVersion Include="Snappier" Version="1.1.6" />
     <PackageVersion Include="System.CommandLine" Version="2.0.0-beta4.24528.1" />
     <PackageVersion Include="System.Configuration.ConfigurationManager" Version="9.0.1" />

src/Nethermind/Ethereum.Test.Base/BlockchainTestBase.cs

@@ -74,6 +74,7 @@ public UInt256 Calculate(BlockHeader header, BlockHeader parent)
 
     protected async Task<EthereumTestResult> RunTest(BlockchainTest test, Stopwatch? stopwatch = null, bool failOnInvalidRlp = true)
     {
+        Debug.WriteLine("============================================================================================================");
         TestContext.Out.WriteLine($"Running {test.Name}, Network: [{test.Network.Name}] at {DateTime.UtcNow:HH:mm:ss.ffffff}");
         if (test.NetworkAfterTransition is not null)
             TestContext.Out.WriteLine($"Network after transition: [{test.NetworkAfterTransition.Name}] at {test.TransitionForkActivation}");

src/Nethermind/Nethermind.Api/IBasicApi.cs

@@ -13,6 +13,7 @@
 using Nethermind.Core.Timers;
 using Nethermind.Crypto;
 using Nethermind.Db;
+using Nethermind.Evm.Config;
 using Nethermind.KeyStore;
 using Nethermind.Logging;
 using Nethermind.Serialization.Json;
@@ -33,6 +34,7 @@ public interface IBasicApi
         ICryptoRandom CryptoRandom { get; }
         IDbProvider? DbProvider { get; set; }
         IDbFactory? DbFactory { get; set; }
+        IVMConfig? VMConfig { get; }
         IEthereumEcdsa? EthereumEcdsa { get; set; }
         [SkipServiceCollection]
         IJsonSerializer EthereumJsonSerializer { get; }

src/Nethermind/Nethermind.Api/NethermindApi.cs

@@ -54,6 +54,7 @@
 using Nethermind.Wallet;
 using Nethermind.Sockets;
 using Nethermind.Trie;
+using Nethermind.Evm.Config;
 using Nethermind.Consensus.Processing.CensorshipDetector;
 using Nethermind.Facade.Find;
 
@@ -123,6 +124,7 @@ public IBlockchainBridge CreateBlockchainBridge()
         }
 
         public IAbiEncoder AbiEncoder { get; } = Nethermind.Abi.AbiEncoder.Instance;
+        public IVMConfig? VMConfig { get; }
         public IBlobTxStorage? BlobTxStorage { get; set; }
         public CompositeBlockPreprocessorStep BlockPreprocessor { get; } = new();
         public IBlockProcessingQueue? BlockProcessingQueue { get; set; }

src/Nethermind/Nethermind.Benchmark.Runner/Program.cs

@@ -1,6 +1,8 @@
 // SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited
 // SPDX-License-Identifier: LGPL-3.0-only
 
+
+// #define BENCHMARK
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Reflection;
@@ -11,6 +13,20 @@
 using BenchmarkDotNet.Running;
 using System.Linq;
 using BenchmarkDotNet.Toolchains.InProcess.NoEmit;
+using Nethermind.Evm.Benchmark;
+using Nethermind.Evm.Config;
+using Nethermind.Abi;
+using Nethermind.Evm;
+using System;
+using Nethermind.Core.Extensions;
+using NSubstitute;
+using Nethermind.Int256;
+using BenchmarkDotNet.Toolchains.DotNetCli;
+using CommandLine;
+using System.IO;
+using Nethermind.Evm.CodeAnalysis.IL;
+using static Nethermind.Evm.VirtualMachine;
+using Microsoft.Diagnostics.Runtime;
 using BenchmarkDotNet.Columns;
 using Nethermind.Precompiles.Benchmark;
 
@@ -46,14 +62,106 @@ public PrecompileBenchmarkConfig() : base(Job.MediumRun.WithRuntime(CoreRuntime.
 
     public static class Program
     {
+        public class Options
+        {
+            [Option('m', "mode", Default = "full", Required = true, HelpText = "Available modes: full, evm, ilevm")]
+            public string Mode { get; set; }
+
+            [Option('b', "bytecode", Required = false, HelpText = "Hex encoded bytecode")]
+            public string ByteCode { get; set; }
+
+            [Option('n', "identifier", Required = false, HelpText = "Benchmark Name")]
+            public string Name { get; set; }
+
+            [Option('c', "config", Required = false, HelpText = "EVM configs : 0-STD, 2-AOT")]
+            public string Config { get; set; }
+        }
+
+        public static void Run(ILocalSetup setup, int iterations)
+        {
+            for (int i = 0; i < iterations; i++)
+            {
+                setup.Setup();
+                setup.Run();
+                setup.Reset();
+            }
+        }
+
         public static void Main(string[] args)
         {
-            List<Assembly> additionalJobAssemblies = [
+            ParserResult<Options> options = Parser.Default.ParseArguments<Options>(args);
+            switch (options.Value.Mode)
+            {
+                case "full":
+                    RunFullBenchmark(args);
+                    break;
+                case "evm":
+                    RunEvmBenchmarks(options.Value);
+                    break;
+                case "ilevm":
+                    RunIlEvmBenchmarks(options.Value);
+                    break;
+                default:
+                    throw new Exception("Invalid mode");
+            }
+        }
+
+        public static void RunEvmBenchmarks(Options options)
+        {
+            int mode = 1 | 2 | 4 | 8;
+            Environment.SetEnvironmentVariable("NETH.BENCHMARK.BYTECODE.MODE", mode.ToString());
+
+            if (String.IsNullOrEmpty(options.ByteCode) || String.IsNullOrEmpty(options.Name))
+            {
+                BenchmarkRunner.Run(typeof(Nethermind.Evm.Benchmark.EvmBenchmarks), new DashboardConfig(Job.VeryLongRun.WithRuntime(CoreRuntime.Core90)));
+            }
+            else
+            {
+                string bytecode = options.ByteCode;
+                if (Path.Exists(bytecode))
+                {
+                    bytecode = File.ReadAllText(bytecode);
+                }
+
+                Environment.SetEnvironmentVariable("NETH.BENCHMARK.BYTECODE.CODE", bytecode);
+                Environment.SetEnvironmentVariable("NETH.BENCHMARK.BYTECODE.NAME", options.Name);
+                var summary = BenchmarkRunner.Run<CustomEvmBenchmarks>(new DashboardConfig(Job.MediumRun.WithRuntime(CoreRuntime.Core90)));
+            }
+        }
+
+
+        public static void RunIlEvmBenchmarks(Options options)
+        {
+            Environment.SetEnvironmentVariable("NETH.BENCHMARK.BYTECODE.MODE", options.Config);
+
+            if (String.IsNullOrEmpty(options.ByteCode) || String.IsNullOrEmpty(options.Name))
+            {
+                BenchmarkRunner.Run(typeof(Nethermind.Evm.Benchmark.EvmBenchmarks), new DashboardConfig(Job.VeryLongRun.WithRuntime(CoreRuntime.Core90)));
+            }
+            else
+            {
+                string bytecode = options.ByteCode;
+                if (Path.Exists(bytecode))
+                {
+                    bytecode = File.ReadAllText(bytecode);
+                }
+
+                Environment.SetEnvironmentVariable("NETH.BENCHMARK.BYTECODE.CODE", bytecode);
+                Environment.SetEnvironmentVariable("NETH.BENCHMARK.BYTECODE.Name", options.Name);
+                var summary = BenchmarkRunner.Run<CustomEvmBenchmarks>(new DashboardConfig(Job.MediumRun.WithRuntime(CoreRuntime.Core90)));
+            }
+        }
+
+        public static void RunFullBenchmark(string[] args)
+        {
+            List<Assembly> additionalJobAssemblies = new()
+            {
                 typeof(JsonRpc.Benchmark.EthModuleBenchmarks).Assembly,
                 typeof(Benchmarks.Core.Keccak256Benchmarks).Assembly,
                 typeof(Evm.Benchmark.EvmStackBenchmarks).Assembly,
                 typeof(Network.Benchmarks.DiscoveryBenchmarks).Assembly,
-            ];
+                typeof(Precompiles.Benchmark.KeccakBenchmark).Assembly
+            };
 
             List<Assembly> simpleJobAssemblies = [
                 // typeof(EthereumTests.Benchmark.EthereumTests).Assembly,
@@ -67,7 +175,7 @@ public static void Main(string[] args)
             {
                 foreach (Assembly assembly in additionalJobAssemblies)
                 {
-                    BenchmarkRunner.Run(assembly, new DashboardConfig(Job.MediumRun.WithRuntime(CoreRuntime.Core90)), args);
+                    BenchmarkRunner.Run(assembly, new DashboardConfig(Job.MediumRun.WithRuntime(CoreRuntime.Core80)), args);
                 }
 
                 foreach (Assembly assembly in simpleJobAssemblies)

src/Nethermind/Nethermind.Benchmark.Runner/Properties/launchSettings.json

@@ -0,0 +1,8 @@
+{
+  "profiles": {
+    "Nethermind.Benchmark.Runner": {
+      "commandName": "Project",
+      "commandLineArgs": "-m ilevm -c 2"
+    }
+  }
+}

src/Nethermind/Nethermind.Core/Collections/ArrayPoolList.cs

@@ -375,19 +375,19 @@ public void Dispose()
         GC.SuppressFinalize(this);
 #endif
     }
-
 #if DEBUG
     private readonly StackTrace _creationStackTrace = new();
 
+    /*
     ~ArrayPoolList()
     {
         if (_capacity != 0 && !_disposed)
         {
             throw new InvalidOperationException($"{nameof(ArrayPoolList<T>)} hasn't been disposed. Created {_creationStackTrace}");
         }
     }
+    */
 #endif
-
     public Span<T> AsSpan() => _array.AsSpan(0, Count);
     public Memory<T> AsMemory() => new(_array, 0, Count);
     public ReadOnlyMemory<T> AsReadOnlyMemory() => new(_array, 0, Count);

src/Nethermind/Nethermind.Core/Extensions/IntExtensions.cs

@@ -9,6 +9,11 @@ namespace Nethermind.Core.Extensions;
 
 public static class IntExtensions
 {
+    public static bool HasFlag(this int @this, int flag)
+    {
+        return (@this & flag) == flag;
+    }
+
     public static string ToHexString(this int @this)
     {
         return $"0x{@this:x}";