sebastienros.jint/Jint.Benchmark/UncacheableExpressionsBenchmark.cs

using System.Text;
using BenchmarkDotNet.Attributes;
using Jint.Native;
using Newtonsoft.Json;
using Undefined = Jint.Native.Undefined;

namespace Jint.Benchmark
{
    /// <summary>
    /// Test case for situation where object is projected via filter and map, Jint deems code as uncacheable.
    /// </summary>
    [MemoryDiagnoser]
    public class UncacheableExpressionsBenchmark
    {
        private Document doc;

        private string targetObject;
        private JsValue[] targetJsObject;

        private const string NonArrowFunctionScript = @"
function output(d) {
    var doc = d.SubDocuments.find(function(x){return x.Id==='testing';});
    return { Id : d.Id, Deleted : d.Deleted, SubTestId : (doc!==null&&doc!==undefined)?doc.Id:null, Values : d.SubDocuments.map(function(x){return {TargetId:x.TargetId,TargetValue:x.TargetValue,SubDocuments:x.SubDocuments.filter(function(s){return (s!==null&&s!==undefined);}).map(function(s){return {TargetId:s.TargetId,TargetValue:s.TargetValue};})};}) };
}
";

        private const string ArrowFunctionScript = @"
function output(d) {
    let doc = d.SubDocuments.find(x => x.Id==='testing');
    return { Id : d.Id, Deleted : d.Deleted, SubTestId : (doc!==null&&doc!==undefined)?doc.Id:null, Values : d.SubDocuments.map(x => ({ TargetId:x.TargetId,TargetValue:x.TargetValue,SubDocuments:x.SubDocuments.filter(s => (s!==null&&s!==undefined)).map(s => ({ TargetId: s.TargetId, TargetValue: s.TargetValue}))})) };
}
";

        private Engine engine;

        public class Document
        {
            public string Id { get; set; }
            public string TargetId { get; set; }
            public decimal TargetValue { get; set; }
            public bool Deleted { get; set; }
            public IEnumerable<Document> SubDocuments { get; set; }
        }

        [GlobalSetup]
        public void Setup()
        {
            doc = new Document
            {
                Deleted = false,
                SubDocuments = new List<Document>
                {
                    new Document
                    {
                        TargetId = "id1",
                        SubDocuments = Enumerable.Range(1, 200).Select(x => new Document()).ToList()
                    },
                    new Document
                    {
                        TargetId = "id2",
                        SubDocuments = Enumerable.Range(1, 200).Select(x => new Document()).ToList()
                    }
                }
            };

            using (var stream = new MemoryStream())
            {
                using (var writer = new StreamWriter(stream))
                {
                    JsonSerializer.CreateDefault().Serialize(writer, doc);
                    writer.Flush();

                    var targetObjectJson = Encoding.UTF8.GetString(stream.ToArray());
                    targetObject = $"var d = {targetObjectJson};";
                }
            }

            CreateEngine(Arrow ? ArrowFunctionScript : NonArrowFunctionScript);
        }

        private static void InitializeEngine(Options options)
        {
            options
                .LimitRecursion(64)
                .MaxStatements(int.MaxValue)
                .Strict()
                .LocalTimeZone(TimeZoneInfo.Utc);
        }

        [Params(500)]
        public int N { get; set; }

        [Params(true, false)]
        public bool Arrow { get; set; }

        [Benchmark]
        public void Benchmark()
        {
            var call = engine.GetValue("output").TryCast<ICallable>();
            for (int i = 0; i < N; ++i)
            {
                call.Call(Undefined.Instance, targetJsObject);
            }
        }

        private void CreateEngine(string script)
        {
            engine = new Engine(InitializeEngine);
            engine.Execute(script);
            engine.Execute(targetObject);
            targetJsObject = new[] {engine.GetValue("d")};
        }
    }
}