/base/Applications/Benchmarks/SharedHeap/SharedHeapBench.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="Show attributes associated with a file", 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 SharedHeapBench.AppMain(this);

        }

    }

    //

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

    // create a process.

    //

    public class SharedHeapBench

    {

        internal static int AppMain(Parameters! config)

        {

            int iterations = 10000;



            Console.Write("\nTime alloc/free ops in the shared heap\n\n");



            TimeCycle(10, iterations);



            Thread.Sleep(1000);



            TimeCycle(100, iterations);



            Thread.Sleep(1000);



            TimeCycle(1000, iterations);



            Thread.Sleep(1000);



            TimeCycle(10000, iterations);



            return 0;

        }



        //

        // The goal of this routine is to focus on the shared heap operations

        // themselves.  So we allocate and then free the same amount of memory

        // repeatedly, which (for small region allocations) won't cause us to

        // go to the Page manager in steady state.

        //

        public static void TimeCycle(int bytes, int iterations)

        {



            ulong before = Processor.CycleCount;



            for (int loop = 0; loop < iterations; loop++) {

                    SharedHeapService.Allocation *mem;



                    mem = (SharedHeapService.Allocation *)

                        SharedHeapService.Allocate((UIntPtr)bytes, typeof(byte).GetSystemType(), 0);

                    SharedHeapService.Free(mem);

            }



            ulong after = Processor.CycleCount;



            //

            // Tell the world.

            //

            Console.Write("\nTested {0} alloc/free iterations of {1} bytes\n",

                          iterations, bytes);

            Console.Write("Total cycles: {0}\n", after - before);

            Console.Write("\n\n");

        }

    }

}