using System;
using System.Diagnostics;

namespace CodeDrafts
{
    static class Program
    {
        struct A
        {
            public uint a1;
            public uint a2;
        }

        struct B
        {
            public ulong b1;
        }

        unsafe static B FromAUnsafe(A a)
        {
            return *(B*) &a;
        }

        static void Main(string[] args)
        {
            if (IntPtr.Size != 4)
                throw new InvalidOperationException("Run as x86");

            Console.WindowWidth = 120;

            const int Count = 100*1000*1000;

            Measure("BCallBoxStore", () =>
            {
                var a = new A() { a1 = 1, a2 = 2};
                var b = new B();
                for (int i = 0; i < Count; i++)
                {
                    b = FromAUnsafe(a);
                }
                Call1(b);
                return Count;
            });

            Measure("BCallStore", () =>
            {
                var a = new A() { a1 = 1, a2 = 2 };
                var b = new B();
                for (int i = 0; i < Count; i++)
                {
                    b = FromAUnsafe(a);
                }
                Call2(b);
                return Count;
            });

            Measure("BCallBox", () =>
            {
                var a = new A() { a1 = 1, a2 = 2 };
                var b = new B();
                for (int i = 0; i < Count; i++)
                {
                    b = FromAUnsafe(a);
                }
                Call3(b);
                return Count;
            });

            Measure("BCall", () =>
            {
                var a = new A() { a1 = 1, a2 = 2 };
                var b = new B();
                for (int i = 0; i < Count; i++)
                {
                    b = FromAUnsafe(a);
                }
                Call4(b);
                return Count;
            });

            Measure("BNoCall", () =>
            {
                var a = new A() { a1 = 1, a2 = 2 };
                var b = new B();
                for (int i = 0; i < Count; i++)
                {
                    b = FromAUnsafe(a);
                }
                return Count;
            });
            Console.Write("Done...");
            Console.ReadKey();
        }

        private static object _b1;

        private static void Call1(object b)
        {
            _b1 = (B) b;
        }

        private static B _b2;

        private static void Call2(B b)
        {
            _b2 = b;
        }

        private static void Call3(object b)
        {
        }

        private static void Call4(B b)
        {
        }

        private static void Measure(string name, Func<long> callback)
        {
            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();

            var mem = GC.GetTotalMemory(true);
            var gc00 = GC.CollectionCount(0);
            var gc01 = GC.CollectionCount(1);
            var gc02 = GC.CollectionCount(2);

            var sw = Stopwatch.StartNew();
            var result = callback();
            sw.Stop();

            var mem2 = GC.GetTotalMemory(false);
            var gc10 = GC.CollectionCount(0);
            var gc11 = GC.CollectionCount(1);
            var gc12 = GC.CollectionCount(2);

            var memDelta = (mem2 - mem)/1024.0;
            var gcDelta0 = gc10 - gc00;
            var gcDelta1 = gc11 - gc01;
            var gcDelta2 = gc12 - gc02;

            Console.WriteLine(
                "{0,20}: {1,5}ms, ips: {2,22:N} | Mem: {3,9:N2} kb, GC 0/1/2: {4}/{5}/{6} => {7,6}",
                name, sw.ElapsedMilliseconds, result/sw.Elapsed.TotalSeconds, memDelta, gcDelta0, gcDelta1, gcDelta2, result);
        }
    }
}