/base/Applications/Benchmarks/CreateProcess/CreateProcess.cs

///////////////////////////////////////////////////////////////////////////////

//

//  Microsoft Research Singularity

//

//  Copyright (c) Microsoft Corporation.  All rights reserved.

//

//  Note:   Singularity micro-benchmark program.

//

using Microsoft.Singularity;

using Microsoft.Singularity.V1.Services;

using Microsoft.Singularity.V1.Threads;

using System;

using System.Runtime.CompilerServices;

using System.Diagnostics;

using System.Threading;



using Microsoft.Singularity.Channels;

using Microsoft.Contracts;

using Microsoft.SingSharp.Reflection;

using Microsoft.Singularity.Applications;

using Microsoft.Singularity.Io;

using Microsoft.Singularity.Configuration;

[assembly: Transform(typeof(ApplicationResourceTransform))]



namespace Microsoft.Singularity.Applications 

{

    [ConsoleCategory(HelpMessage="CreateProcess benchmark test", DefaultAction=true)]

    internal class Parameters 

    {

        [InputEndpoint("data")]

        public readonly TRef<UnicodePipeContract.Exp:READY> Stdin;



        [OutputEndpoint("data")]

        public readonly TRef<UnicodePipeContract.Imp:READY> Stdout;



        [BoolParameter( "q", Default=false, HelpMessage="Quiet Mode.")]

        internal bool quietMode;



        [LongParameter( "r", Default=1, HelpMessage="Repetition count.")]

        internal long repetitions;



        reflective internal Parameters();



        internal int AppMain() {

            return CreateProcessTest.AppMain(this);

        }

    }



    //

    // The goal of this test is to time how long it takes to

    // create a process.

    //

    public class CreateProcessTest

    {

        private static bool AtRing3;



#if x64_PERF

        [CLSCompliant(false)]

        public struct PerfEvtSel

        {

            // Bits and Flags

            public const uint CNT_MASK  = 0xff000000;

            public const uint INV       = 0x00800000;

            public const uint EN        = 0x00400000;

            public const uint INT       = 0x00100000;

            public const uint PC        = 0x00080000;

            public const uint E         = 0x00040000;

            public const uint OS        = 0x00020000;

            public const uint USR       = 0x00010000;

            public const uint UNIT_MASK = 0x0000ff00;

            public const uint SELECTOR  = 0x000000ff;



            // Common setting: Count all, but don't interrupt,

            public const uint COUNT     = (EN | PC | OS | USR);



            // Selector values.

            public const uint DtlbL1MissL2Hit                   = 0x45; // Speculative

            public const uint DtlbL1MissL2Miss                  = 0x46; // Speculative

            public const uint CyclesNotHalted                   = 0x76;

            public const uint RequestsToL2Cache                 = 0x7d;

            public const uint ItlbL1MissL2Hit                   = 0x84;

            public const uint ItlbL1MissL2Miss                  = 0x85;

            public const uint RetiredInstructions               = 0xc0;

            public const uint RetiredBranchInstructions         = 0xc2;

            public const uint RetiredBranchesMispredicted       = 0xc3;

            public const uint RetiredBranchesTaken              = 0xc4;

            public const uint CyclesInterruptsMasked            = 0xcd;

            public const uint CyclesInterruptsBlocked           = 0xce;

        }



        public static void Reset(uint pmc, ulong value)

        {

            // Clear the event selector.

            Processor.WriteMsr(0xc0010000 + pmc, 0);

            // Clear the performance counter.

            Processor.WriteMsr(0xc0010004 + pmc, 0);

            // Enable the event selector.

            Processor.WriteMsr(0xc0010000 + pmc, value);

        }



        public static string EvtSelToString(ulong value)

        {

            switch (value & 0xff) {

                case PerfEvtSel.DtlbL1MissL2Hit:            return "DTLB_L2_Hit";

                case PerfEvtSel.DtlbL1MissL2Miss:           return "DTBL_L2_Miss";

                case PerfEvtSel.CyclesNotHalted:            return "CyclesNotHalted";

                case PerfEvtSel.RequestsToL2Cache:          return "TLB_L2_Requests";

                case PerfEvtSel.ItlbL1MissL2Hit:            return "ITLB_L2_Hit";

                case PerfEvtSel.ItlbL1MissL2Miss:           return "ITLB_L2_Miss";

                case PerfEvtSel.RetiredInstructions:        return "Retired_Inst.";

                case PerfEvtSel.RetiredBranchInstructions:  return "Branches";

                case PerfEvtSel.RetiredBranchesMispredicted:return "Br_Mispredicted";

                case PerfEvtSel.RetiredBranchesTaken:       return "Br_Taken";

                case PerfEvtSel.CyclesInterruptsMasked:     return "Ints_Masked (cyc)";

                case PerfEvtSel.CyclesInterruptsBlocked:    return "Ints_Blocked (cyc)";

                default:

                    return String.Format("{0:x16}", value);

            }

        }



        private static ulong x64_i0, x64_p0;

        private static ulong x64_i1, x64_p1;

        private static ulong x64_i2, x64_p2;

        private static ulong x64_i3, x64_p3;

#endif



        private static void DualWriteLine(string message)

        {

            Console.WriteLine(message);

            DebugStub.WriteLine(message);

        }



        public struct PerfSnap

        {

            private bool disabled;

            private long begCycleCount;

            private long endCycleCount;

            private long begSwitchCount;

            private long endSwitchCount;

            private long begInterruptCount;

            private long endInterruptCount;

            private long begKernelGcCount;

            private long endKernelGcCount;

            private long begProcessGcCount;

            private long endProcessGcCount;

            private long iterations;

            private ulong begAllocatedCount;

            private ulong begAllocatedBytes;

            private ulong begFreedCount;

            private ulong begFreedBytes;

            private ulong endAllocatedCount;

            private ulong endAllocatedBytes;

            private ulong endFreedCount;

            private ulong endFreedBytes;

            private ulong begStackGets;

            private ulong begStackRets;

            private ulong endStackGets;

            private ulong endStackRets;





            public long Cycles      { get { return endCycleCount - begCycleCount; } }

            public long Interrupts  { get { return endInterruptCount - begInterruptCount; } }

            public long Switches    { get { return endSwitchCount - begSwitchCount; } }

            public long KernelGCs   { get { return endKernelGcCount - begKernelGcCount; } }

            public long ProcessGCs  { get { return endProcessGcCount - begProcessGcCount; } }

            public ulong AllocatedCount { get { return endAllocatedCount-begAllocatedCount; } }

            public ulong AllocatedBytes { get { return endAllocatedBytes-begAllocatedBytes; } }

            public ulong FreedCount { get { return endFreedCount - begFreedCount; } }

            public ulong FreedBytes { get { return endFreedBytes - begFreedBytes; } }

            public ulong StackGets { get { return endStackGets - begStackGets; } }

            public ulong StackRets { get { return endStackRets - begStackRets; } }



            public void Start()

            {

                if (!AtRing3) {

                    disabled = Processor.DisableLocalPreemption();

                }



                int collectorCount;

                long collectorMillis;

                long collectorBytes;

                GC.PerformanceCounters(out collectorCount,

                                       out collectorMillis,

                                       out collectorBytes);



                ulong stackGets;

                ulong stackRets;

                StackService.GetUsageStatistics(out stackGets,

                                                out stackRets);

                begStackGets = stackGets;

                begStackRets = stackRets;



                ulong allocatedCount;

                ulong allocatedBytes;

                ulong freedCount;

                ulong freedBytes;

                PageTableService.GetUsageStatistics(out allocatedCount,

                                                    out allocatedBytes,

                                                    out freedCount,

                                                    out freedBytes);

                begAllocatedCount = allocatedCount;

                begAllocatedBytes = allocatedBytes;

                begFreedCount = freedCount;

                begFreedBytes = freedBytes;



                begInterruptCount = ProcessService.GetKernelInterruptCount();

                begSwitchCount = ProcessService.GetContextSwitchCount();

                begKernelGcCount = ProcessService.GetKernelGcCount();

                begProcessGcCount = collectorCount;



#if x64_PERF

                // Set up for perf counting

                if (!AtRing3) {

                    // Reset the performance counters to what we're interested in.

                    Reset(0, PerfEvtSel.COUNT | PerfEvtSel.CyclesNotHalted);

                    Reset(1, PerfEvtSel.COUNT | PerfEvtSel.RetiredInstructions);

                    Reset(2, PerfEvtSel.COUNT | PerfEvtSel.RetiredBranchInstructions);

                    Reset(3, PerfEvtSel.COUNT | PerfEvtSel.RequestsToL2Cache | 0x400);

                }

                else {

                    // We're not allowed to reset the perf counters, so take note

                    // of their current values; we will subtract from this later.

                    x64_i0 = Processor.ReadPmc(0);

                    x64_i1 = Processor.ReadPmc(1);

                    x64_i2 = Processor.ReadPmc(2);

                    x64_i3 = Processor.ReadPmc(3);

                }

#endif



                begCycleCount = unchecked((long)Processor.CycleCount);

            }



            public void Finish(long iterations)

            {

                endCycleCount = unchecked((long)Processor.CycleCount);



#if X64_PERF

                x64_p0 = Processor.ReadPmc(0);

                x64_p1 = Processor.ReadPmc(1);

                x64_p2 = Processor.ReadPmc(2);

                x64_p3 = Processor.ReadPmc(3);

#endif



                endInterruptCount = ProcessService.GetKernelInterruptCount();

                endSwitchCount = ProcessService.GetContextSwitchCount();

                endKernelGcCount = ProcessService.GetKernelGcCount();



                int collectorCount;

                long collectorMillis;

                long collectorBytes;

                GC.PerformanceCounters(out collectorCount,

                                       out collectorMillis,

                                       out collectorBytes);

                endProcessGcCount = collectorCount;



                ulong allocatedCount;

                ulong allocatedBytes;

                ulong freedCount;

                ulong freedBytes;

                PageTableService.GetUsageStatistics(out allocatedCount,

                                                    out allocatedBytes,

                                                    out freedCount,

                                                    out freedBytes);

                endAllocatedCount = allocatedCount;

                endAllocatedBytes = allocatedBytes;

                endFreedCount = freedCount;

                endFreedBytes = freedBytes;



                ulong stackGets;

                ulong stackRets;

                StackService.GetUsageStatistics(out stackGets,

                                                out stackRets);

                endStackGets = stackGets;

                endStackRets = stackRets;



                if (!AtRing3) {

                    Processor.RestoreLocalPreemption(disabled);

                }



                this.iterations = iterations;

            }



            public void Display(string name)

            {

                DualWriteLine(

                    String.Format("{0,-16} {1,6:d} x{2,8:d} ={3,12:d} " +

                                  "[swi={4,6:d} int={5,3:d} gc={6:d}/{7:d}]",

                                  name,

                                  iterations,

                                  Cycles / iterations,

                                  Cycles,

                                  Switches,

                                  Interrupts,

                                  KernelGCs,

                                  ProcessGCs)

                    );





                if (AllocatedCount != 0 || FreedCount != 0 || StackGets != 0) {

                    DualWriteLine(

                        string.Format(

                            "                       " +

                            "[alloc={0,4:d}/{1,8:x} free={2,4:d}/{3,8:x} " +

                            "stack={4,4:d}/{5,4:d}]",

                            AllocatedCount,

                            AllocatedBytes,

                            FreedCount,

                            FreedBytes,

                            StackGets,

                            StackRets)

                        );

                }



#if x64_PERF

                if (!AtRing3) {

                    // Read off the current MSR values and turn them

                    // into nice labels

                    ulong e0 = Processor.ReadMsr(0xc0010000);

                    ulong e1 = Processor.ReadMsr(0xc0010001);

                    ulong e2 = Processor.ReadMsr(0xc0010002);

                    ulong e3 = Processor.ReadMsr(0xc0010003);



                    DualWriteLine(

                        String.Format("evt: {0,16} {1,16} {2,16} {3,16}",

                                      EvtSelToString(e0),

                                      EvtSelToString(e1),

                                      EvtSelToString(e2),

                                      EvtSelToString(e3)));

                }

                else {

                    // Subtract from the initial perf-counter values to

                    // get the delta we want

                    x64_p0 -= x64_i0;

                    x64_p1 -= x64_i1;

                    x64_p2 -= x64_i2;

                    x64_p3 -= x64_i3;

                }



                DualWriteLine(

                    String.Format("pmc: {0:d16} {1:d16} {2:d16} {3:d16} {4:d16}\n\n",

                                  Cycles, x64_p0, x64_p1, x64_p2, x64_p3));

#endif

            }

        }





        internal static int AppMain(Parameters! config)

        {

            bool runQuiet = config.quietMode;

            long repetitions = config.repetitions; 



            Console.Write("\nProcess creation test\n\n");

            string [] arguments;

            for (long i = 0; i < repetitions; i++) {

                arguments = new string[2];

                arguments[0] = "testpe";

                arguments[1] = "!"; // Special flag to not notify debugger.

                TimeProcess(arguments, runQuiet);

            }

            return 0;

        }



        public static void TimeProcess(String[]! args, bool runQuiet)

        {

            ulong baseline;

            ulong created;

            ulong started;

            ulong exited;

            Process process = null;



            PerfSnap snap = new PerfSnap();



            snap.Start();

            try {

                ProcessService.Waypoint0();

                baseline = Processor.CycleCount;



                //

                // Time process creation.

                //

                ProcessService.Waypoint(1500);

                process = new Process(args);

                created = Processor.CycleCount;



                //

                // Time process start.

                //

                ProcessService.Waypoint(1501);



                process.Start();

                started = Processor.CycleCount;



                ProcessService.Waypoint(1502);

                //

                // Time process execution.

                //

                process.Join();

                ProcessService.Waypoint(1503);

                exited = Processor.CycleCount;

            }

            finally {

                snap.Finish(1);

            }



            snap.Display("CreateProc");



            ProcessService.Waypoint(1504);

            process.Dispose(true);

            ProcessService.Waypoint(1505);

            ProcessService.WaypointDump();





            if (runQuiet) {

                return;

            }



            //

            // Tell the world.

            //

            Console.WriteLine();

            Console.WriteLine("Tested process: {0}", args[0]);

            Console.WriteLine("Create process: {0,15:d} cycles", created - baseline);

            Console.WriteLine("Start process:  {0,15:d} cycles", started - created);

            Console.WriteLine("Run process:    {0,15:d} cycles", exited - started);

            Console.WriteLine("Total:          {0,15:d} cycles", exited - baseline);

            Console.WriteLine("Process.Create: {0,15:d} cycles", started - baseline);

            Console.WriteLine();

            Console.WriteLine();

        }

    }

}