singrdk/base/Applications/Tests/SharedHeapTest/SharedHeapTest.cs

///////////////////////////////////////////////////////////////////////////////
//
//  Microsoft Research Singularity
//
//  Copyright (c) Microsoft Corporation.  All rights reserved.
//
//  Note: User-mode test program for calling shared heap through the ABI.
//

using Microsoft.Singularity.V1.Services;
using System;
using System.Runtime.CompilerServices;
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(DefaultAction=true)]
    internal class Parameters {
        [InputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Exp:READY> Stdin;

        [OutputEndpoint("data")]
        public readonly TRef<UnicodePipeContract.Imp:READY> Stdout;

        reflective internal Parameters();

        internal int AppMain() {
            SharedHeapTest.AppMain(this);
            return 0;
        }
    }

    unsafe public class SharedHeapTest
    {
        //
        // Note: The integrity check relies on there being one bit in each byte
        // to represent the owning concurrent allocation slot, so the number of
        // concurrent allocations can't exceed 8.
        //
        private const uint ConcurrentAllocations = 8;
        private SharedHeapService.Allocation*[]! mem;

        Random! random = new Random();

        internal static void AppMain(Parameters! config)
        {
            SharedHeapTest test = new SharedHeapTest();

            uint Iterations = 10;

            Console.WriteLine("Starting Shared Heap Test\n");
            test.StartUp();
            for (uint loop = 0; loop < Iterations; loop++) {
                test.Perturb();
                if (test.Check() == false) {
                    break;
                }
            }
        }

        private SharedHeapTest() {
            //
            // Create an array to hold our concurrent allocations.
            //
            this.mem = new SharedHeapService.Allocation*[ConcurrentAllocations];
        }

        public static void Usage()
        {
            Console.WriteLine("Usage: sharedheap [Iterations]\n");
        }

        public void StartUp()
        {
            //
            // Allocating a bunch of randomly sized things.
            //
            for (uint loop = 0; loop < ConcurrentAllocations; loop++) {
                AllocRandomSizedThingy(loop);
                if (CheckForValue(loop, 0) == true) {
                    Console.WriteLine("Passed zero-fill test.\n");
                }
                else {
                    Console.WriteLine("Failed zero-fill test.\n");
                }
                FillWithValue(loop, (byte)(1 << (int)loop));
            }
        }

        public bool Check()
        {
            //
            // Check all allocations for expected bit settings.
            //
            Console.WriteLine("--------\n");
            Console.WriteLine("Integrity Check\n");

            for (uint loop = 0; loop < ConcurrentAllocations; loop++) {
                if (CheckBits(loop, (byte)(1 << (int)loop)) == false) {
                    return false;
                }
            }

            Console.WriteLine("--------\n");
            return true;
        }

        public void Perturb()
        {
            //
            // Pick an element slot to use and an action to take.
            //
            uint which = (uint)random.Next(ConcurrentAllocations);
            uint action = (uint)random.Next(3);

            //
            // Free up the slot.
            //
            Console.WriteLine("--------\n");
            Console.WriteLine(
                "Freeing region: Data = {0}, Size = {1}.\n",
                SharedHeapService.GetData(this.mem[which]),
                SharedHeapService.GetSize(this.mem[which]));

            ClearBits(which, (byte)(1 << (int)which));
            SharedHeapService.Free(this.mem[which]);

            Console.WriteLine("--------\n");

            //
            // Play around.
            //
            switch (action) {
                case 0:
                    //
                    // Allocate something new.
                    //
                    Console.WriteLine("Allocation Test\n");
                    AllocRandomSizedThingy(which);
                    if (CheckForValue(which, 0) == true) {
                        Console.WriteLine("Passed zero-fill test.\n");
                    }
                    else {
                        Console.WriteLine("Failed zero-fill test.\n");
                    }

                    //
                    // Store bit corresponding to slot number in each
                    // data byte.  Used to check integrity later.
                    //
                    FillWithValue(which, (byte)(1 << (int)which));
                    break;

                case 1:
                    //
                    // Split an element in two.  Use the slot we freed
                    // up above to hold the split-off piece.
                    //
                    Console.WriteLine("Split Test\n");

                    //
                    // Pick a region to split.
                    //
                    uint split;
                    do {
                        split = (uint)random.Next(ConcurrentAllocations);
                    } while (split == which);

                    Console.Write(
                        "Splitting region: Data = {0}, Size = {1}",
                        SharedHeapService.GetData(this.mem[split]),
                        SharedHeapService.GetSize(this.mem[split]));
                    UIntPtr offset = (UIntPtr)random.Next(
                        1,
                        (int)SharedHeapService.GetSize(this.mem[split]));
                    Console.WriteLine(" in two at offset {0}.\n", offset);

                    this.mem[which] = SharedHeapService.Split(
                        this.mem[split],
                        offset);

                    Console.WriteLine(
                        "Revised region: Data = {0}, Size = {1}.\n",
                        SharedHeapService.GetData(this.mem[split]),
                        SharedHeapService.GetSize(this.mem[split]));

                    Console.WriteLine(
                        "New region: Data = {0}, Size = {1}.\n",
                        SharedHeapService.GetData(this.mem[which]),
                        SharedHeapService.GetSize(this.mem[which]));

                    //
                    // Remove bit corresponding to the slot of the original
                    // region from the split-off data.  Likewise, add the
                    // bit corresponding to the slot number of the split-off
                    // region to the split-off data.
                    //
                    ClearBits(which, (byte)(1 << (int)split));
                    SetBits(which, (byte)(1 << (int)which));

                    break;

                case 2:
                    //
                    // Share part of a region.  Use the slot we freed
                    // up above to hold the shared piece.
                    //
                    Console.WriteLine("Share Test\n");

                    //
                    // Pick a region to share.
                    //
                    uint share;
                    do {
                        share = (uint)random.Next(ConcurrentAllocations);
                    } while (share == which);

                    Console.Write(
                        "Sharing region: Data = {0}, Size = {1}",
                        SharedHeapService.GetData(this.mem[share]),
                        SharedHeapService.GetSize(this.mem[share]));
                    UIntPtr start = (UIntPtr)random.Next(
                        1,
                        (int)SharedHeapService.GetSize(this.mem[share]));
                    Console.WriteLine(" starting at offset {0}.\n", start);

                    this.mem[which] = SharedHeapService.Share(
                        this.mem[share],
                        start, SharedHeapService.GetSize(this.mem[share]));

                    Console.WriteLine(
                        "Original region: Data = {0}, Size = {1}.\n",
                        SharedHeapService.GetData(this.mem[share]),
                        SharedHeapService.GetSize(this.mem[share]));

                    Console.WriteLine(
                        "New region: Data = {0}, Size = {1}.\n",
                        SharedHeapService.GetData(this.mem[which]),
                        SharedHeapService.GetSize(this.mem[which]));

                    //
                    // Modify each data byte in the shared region to include
                    // the bit corresponding to the slot number of the new
                    // shared allocation handle.
                    //
                    SetBits(which, (byte)(1 << (int)which));

                    break;
            }
        }

        private void AllocRandomSizedThingy(uint index)
        {
            // REVIEW: We can't ask the system for the PageSize?
            // Hardcoded to 2 * Pages.PageSize.
            UIntPtr size = (UIntPtr)random.Next(1, 8192);

            this.mem[index] = SharedHeapService.Allocate(size, typeof(byte).GetSystemType(), 0);

            Console.WriteLine("Allocated region: Data = {0}, Size = {1}.\n",
                              SharedHeapService.GetData(this.mem[index]),
                              SharedHeapService.GetSize(this.mem[index]));
        }

        private void FillWithValue(uint index, byte value)
        {
            UIntPtr data = SharedHeapService.GetData(this.mem[index]);
            UIntPtr size = SharedHeapService.GetSize(this.mem[index]);

            for (UIntPtr address = data; address < data + size; address++) {
                *(byte *)address = value;
            }

            return;
        }

        private bool CheckForValue(uint index, byte value)
        {
            UIntPtr data = SharedHeapService.GetData(this.mem[index]);
            UIntPtr size = SharedHeapService.GetSize(this.mem[index]);
            bool status = true;

            for (UIntPtr address = data; address < data + size; address++) {
                if (*(byte *)address != value) {
                    status = false;
                    Console.Write("Wrong value {0} at address {1}.\n",
                                      *(byte *)address, address);
                    Console.Write("Should be {0}.\n", value);
                }
            }

            return status;
        }

        private void SetBits(uint index, byte bit)
        {
            UIntPtr data = SharedHeapService.GetData(this.mem[index]);
            UIntPtr size = SharedHeapService.GetSize(this.mem[index]);

            for (UIntPtr address = data; address < data + size; address++) {
                *(byte *)address |= bit;
            }

            return;
        }

        private void ClearBits(uint index, byte bit)
        {
            UIntPtr data = SharedHeapService.GetData(this.mem[index]);
            UIntPtr size = SharedHeapService.GetSize(this.mem[index]);

            for (UIntPtr address = data; address < data + size; address++) {
                *(byte *)address &= (byte)~bit;
            }

            return;
        }

        private bool CheckBits(uint index, byte bit)
        {
            UIntPtr data = SharedHeapService.GetData(this.mem[index]);
            UIntPtr size = SharedHeapService.GetSize(this.mem[index]);
            bool status = true;

            for (UIntPtr address = data; address < data + size; address++) {
                if ((*(byte *)address & bit) != bit) {
                    status = false;
                    Console.WriteLine("Bad value {0} at address {1}.\n",
                                      *(byte *)address, address);
                    //
                    // Stop at one to prevent huge output.
                    //
                    break;
                }
            }

            return status;
        }
    }
}