sebastienros.jint/Jint.Benchmark/InteropBenchmark.cs

using System;
using System.Collections.Generic;
using System.Reflection;
using BenchmarkDotNet.Attributes;
using Jint.Native;
using Jint.Native.Array;

namespace Jint.Benchmark
{
    [MemoryDiagnoser]
    public class InteropBenchmark
    {
        private const int OperationsPerInvoke = 1_000;

        public class Person
        {
            public string Name { get; set; }
        }

        private Engine _engine;

        [GlobalSetup]
        public void Setup()
        {
            _engine = new Engine(cfg => cfg.AllowClr(
                    typeof(Person).GetTypeInfo().Assembly,
                    typeof(Console).GetTypeInfo().Assembly,
                    typeof(System.IO.File).GetTypeInfo().Assembly))
                .SetValue("log", new Action<object>(Console.WriteLine))
                .SetValue("assert", new Action<bool>(x => { }))
                .SetValue("equal", new Action<object, object>((x, y) => { }));
        }

        [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
        public void DelegatesCanBeSet()
        {
            for (int i = 0; i < OperationsPerInvoke; ++i)
            {
                _engine.SetValue("square", new Func<double, double>(x => x * x));
                _engine.Execute("assert(square(10) === 100);");
            }
        }

        [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
        public void ExtraParametersAreIgnored()
        {
            for (int i = 0; i < OperationsPerInvoke; ++i)
            {
                _engine.SetValue("passNumber", new Func<int, int>(x => x));
                _engine.Execute("assert(passNumber(123,'test',{},[],null) === 123);");
            }
        }

        [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
        public void GetObjectProperties()
        {
            var p = new Person
            {
                Name = "Mickey Mouse"
            };

            for (int i = 0; i < OperationsPerInvoke; ++i)
            {
                _engine.SetValue("p", p);
                _engine.Execute("assert(p.Name === 'Mickey Mouse');");
            }
        }

        [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
        public void InvokeObjectMethods()
        {
            var p = new Person
            {
                Name = "Mickey Mouse"
            };

            for (int i = 0; i < OperationsPerInvoke; ++i)
            {
                _engine.SetValue("p", p);
                _engine.Execute(@"assert(p.ToString() === 'Mickey Mouse');");
            }
        }

        [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
        public void SetObjectProperties()
        {
            var p = new Person
            {
                Name = "Mickey Mouse"
            };

            for (int i = 0; i < OperationsPerInvoke; ++i)
            {
                _engine.SetValue("p", p);
                _engine.Execute("p.Name = 'Donald Duck'; assert(p.Name === 'Donald Duck');");
            }
        }

        [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
        public void GetIndexUsingStringKey()
        {
            var dictionary = new Dictionary<string, Person>();
            dictionary.Add("person1", new Person {Name = "Mickey Mouse"});
            dictionary.Add("person2", new Person {Name = "Goofy"});

            for (int i = 0; i < OperationsPerInvoke; ++i)
            {
                _engine.SetValue("dictionary", dictionary);
                _engine.Execute("assert(dictionary['person1'].Name === 'Mickey Mouse'); assert(dictionary['person2'].Name === 'Goofy');");
            }
        }

        [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
        public void GenericMethods()
        {
            var dictionary = new Dictionary<int, string>
            {
                {1, "Mickey Mouse"}
            };

            for (int i = 0; i < OperationsPerInvoke; ++i)
            {
                _engine.SetValue("dictionary", dictionary);
                _engine.Execute("dictionary.Clear(); dictionary.Add(2, 'Goofy'); assert(dictionary[2] === 'Goofy');");
            }
        }

        [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
        public void MultiGenericTypes()
        {
            for (int i = 0; i < OperationsPerInvoke; ++i)
            {
                _engine.Execute(@"
                var type = System.Collections.Generic.Dictionary(System.Int32, System.String);
                var dictionary = new type();
                dictionary.Add(1, 'Mickey Mouse');
                dictionary.Add(2, 'Goofy');
                assert(dictionary[2] === 'Goofy');
            ");
            }
        }

        [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
        public void IndexOnList()
        {
            var list = new List<object>(2);
            list.Add("Mickey Mouse");
            list.Add("Goofy");

            for (int i = 0; i < OperationsPerInvoke; ++i)
            {
                _engine.SetValue("list", list);
                _engine.Execute("list[1] = 'Donald Duck'; assert(list[1] === 'Donald Duck');");
            }
        }


        [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
        public void EcmaValuesAreAutomaticallyConvertedWhenSetInPoco()
        {
            var p = new Person
            {
                Name = "foo",
            };


            for (int i = 0; i < OperationsPerInvoke; ++i)
            {
                _engine.SetValue("p", p);
                _engine.Execute(@"
                assert(p.Name === 'foo');
                assert(p.Age === 0);
                p.Name = 'bar';
                p.Age = 10;
            ");
            }
        }

        [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
        public void Trim()
        {
            var p = new Person
            {
                Name = "Mickey Mouse "
            };
            for (int i = 0; i < OperationsPerInvoke; ++i)
            {
                _engine.SetValue("p", p);
                _engine.Execute(@"
                assert(p.Name === 'Mickey Mouse ');
                p.Name = p.Name.trim();
                assert(p.Name === 'Mickey Mouse');
            ");
            }
        }

        [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
        public void MathFloor()
        {
            var p = new Person();
            for (int i = 0; i < OperationsPerInvoke; ++i)
            {
                _engine.SetValue("p", p);
                _engine.Execute("p.Age = Math.floor(1.6); assert(p.Age === 1);");
            }
        }

        [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
        public void DelegateAsFunction()
        {
            var even = new Func<int, bool>(x => x % 2 == 0);

            for (int i = 0; i < OperationsPerInvoke; ++i)
            {
                _engine.SetValue("even", even);
                _engine.Execute("assert(even(2) === true);");
            }
        }

        [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
        public void ConvertArrayToArrayInstance()
        {
            var ints = new[] {1, 2, 3, 4, 5, 6};
            for (int i = 0; i < OperationsPerInvoke; ++i)
            {
                _engine
                    .SetValue("values", ints)
                    .Execute("values.filter(function(x){ return x % 2 == 0; })");
            }
        }

        [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
        public void ConvertListsToArrayInstance()
        {
            var ints = new List<object> {1, 2, 3, 4, 5, 6};
            for (int i = 0; i < OperationsPerInvoke; ++i)
            {
                _engine
                    .SetValue("values", ints)
                    .Execute("new Array(values).filter(function(x){ return x % 2 == 0; })");
            }
        }

        [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
        public void ConvertArrayInstanceToArray()
        {
            for (int i = 0; i < OperationsPerInvoke; ++i)
            {
                _engine.Execute("'[email protected]'.split('@');");
            }
        }

        [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
        public void LoopWithNativeEnumerator()
        {
            JsValue Adder(JsValue argValue)
            {
                ArrayInstance args = argValue.AsArray();
                double sum = 0;
                foreach (var item in args)
                {
                    if (item.IsNumber())
                    {
                        sum += item.AsNumber();
                    }
                }

                return sum;
            }

            for (int i = 0; i < OperationsPerInvoke; ++i)
            {
                _engine.SetValue("getSum", new Func<JsValue, JsValue>(Adder));
                _engine.Execute("getSum([1,2,3]);");
            }
        }
    }
}