Esempio n. 1
0
            public override MethodResult <int> Handle(int i)
            {
                Context.Cache.Set("result", i);

                if (Increment2.IsNull() && Double.IsNull())
                {
                    return(Increment.Inc(i));
                }
                return(i);
            }
        public static void Test()
        {
            const int invocationTestCount = 256;
            const int iterations          = 10000;
            var       switches            = new Switch[invocationTestCount];
            var       virtuals            = new Superclass[invocationTestCount];
            Random    random = new Random(5);

            for (int i = 0; i < invocationTestCount; ++i)
            {
                var executionType = (ExecutionType)random.Next(12);
                switches[i].Type = executionType;
                switch (executionType)
                {
                case ExecutionType.Increment:
                    virtuals[i] = new Increment();
                    break;

                case ExecutionType.Decrement:
                    virtuals[i] = new Decrement();
                    break;

                case ExecutionType.LShift:
                    virtuals[i] = new LShift();
                    break;

                case ExecutionType.RShift:
                    virtuals[i] = new RShift();
                    break;

                case ExecutionType.Scramble1:
                    virtuals[i] = new Scramble1();
                    break;

                case ExecutionType.Scramble2:
                    virtuals[i] = new Scramble2();
                    break;

                case ExecutionType.Increment2:
                    virtuals[i] = new Increment2();
                    break;

                case ExecutionType.Decrement2:
                    virtuals[i] = new Decrement2();
                    break;

                case ExecutionType.LShift2:
                    virtuals[i] = new LShift2();
                    break;

                case ExecutionType.RShift2:
                    virtuals[i] = new RShift2();
                    break;

                case ExecutionType.Scramble12:
                    virtuals[i] = new Scramble12();
                    break;

                case ExecutionType.Scramble22:
                    virtuals[i] = new Scramble22();
                    break;
                }
            }
            int switchValue  = 0;
            int virtualValue = 0;

            //Warmup.
            for (int i = 0; i < invocationTestCount; ++i)
            {
                switches[i].Do(ref switchValue);
                virtuals[i].Do(ref virtualValue);
            }
            var switchStart = Stopwatch.GetTimestamp();

            for (int i = 0; i < iterations; ++i)
            {
                for (int j = 0; j < invocationTestCount; ++j)
                {
                    switches[j].Do(ref switchValue);
                    switches[j].Do(ref switchValue);
                    switches[j].Do(ref switchValue);
                    switches[j].Do(ref switchValue);
                    switches[j].Do(ref switchValue);

                    switches[j].Do(ref switchValue);
                    switches[j].Do(ref switchValue);
                    switches[j].Do(ref switchValue);
                    switches[j].Do(ref switchValue);
                    switches[j].Do(ref switchValue);
                }
            }
            var virtualStart = Stopwatch.GetTimestamp();

            for (int i = 0; i < iterations; ++i)
            {
                for (int j = 0; j < invocationTestCount; ++j)
                {
                    virtuals[j].Do(ref virtualValue);
                    virtuals[j].Do(ref virtualValue);
                    virtuals[j].Do(ref virtualValue);
                    virtuals[j].Do(ref virtualValue);
                    virtuals[j].Do(ref virtualValue);

                    virtuals[j].Do(ref virtualValue);
                    virtuals[j].Do(ref virtualValue);
                    virtuals[j].Do(ref virtualValue);
                    virtuals[j].Do(ref virtualValue);
                    virtuals[j].Do(ref virtualValue);
                }
            }
            var virtualEnd = Stopwatch.GetTimestamp();

            Console.WriteLine($"Switch time (ns): {1e9 * (virtualStart - switchStart) / (Stopwatch.Frequency * invocationTestCount * iterations * 10)}");
            Console.WriteLine($"Virtual time (ns): {1e9 * (virtualEnd - virtualStart) / (Stopwatch.Frequency * invocationTestCount * iterations * 10)}");
            Console.WriteLine($"Switch accumulator: {switchValue}, virtual accumulator: {virtualValue}");
        }