Nsryjdtyk

I have a program in which I want to Simulate a queue. To speed things up (lots of different parameters) I thought that I could use a parallel loop, however the queue object (or at least the objects within that object) are still shared while they are all created within either the MGcC function or the queue object. Is there something I forgot about parallel functions?

The object which gives the trouble is the queue.MyHeap.

(Also if more information is needed please ask as I have left out a lot to make it more readably as you might see in the queue object).

Parallel.ForEach(a, (numbers) =>

{                   

    MGcC(a);

});        



static public Tuple<Customer[,], List<Interval>> MGcC(int a)

{

    Queue queue = new Queue(a);

    return queue.Simulate(writeFile);

}



public class Queue

{

    Func<object, double> arrivalFunction;

    Func<object, double> servingFunction;

    double lambda;

    double v;

    object serviceObject;

    int minServers;

    bool decision;



    int idleServers;

    int activeServers;

    int amountInOrbit;

    protected minHeap myHeap;



    public Queue(double lambda, double v, object serviceObject, int servers, Func<object, double> arrivalFunction, Func<object, double> servingFunction, bool decision = false)

    {

        this.arrivalFunction = arrivalFunction;

        this.servingFunction = servingFunction;

        this.lambda = lambda;

        this.v = v;

        this.serviceObject = serviceObject;

        this.minServers = servers;

        this.decision = decision;



        idleServers = servers;

        activeServers = 0;

        amountInOrbit = 0;

        myHeap = new minHeap();

    }



public class minHeap

{

    static protected Action heap;

    static public int counter;

    public minHeap()

    {

        counter = -1;

        heap = new Action[1000000];

    }



    public Action Pop()

    {

        if (counter < 0)

        {

            Console.WriteLine("empty");

            return new Action(0, 0, new Customer());

        }

        Action returnValue = heap[0];

        heap[0] = heap[counter];

        counter--;

        heapify(0);

        return (returnValue);

    }



    public void Push(Action a)

    {

        counter++;

        heap[counter] = new Action(double.PositiveInfinity, 0, new Customer());

        InsertKey(counter, a);

    }



    static void InsertKey(int i, Action a)

    {

        if (heap[i].TimeOfExecution < a.TimeOfExecution)

            Console.WriteLine("should not have happened");

        heap[i] = a;

        while (i > 0 && heap[Parent(i)].TimeOfExecution > heap[i].TimeOfExecution)

        {

            Action temp = heap[i];

            heap[i] = heap[Parent(i)];

            heap[Parent(i)] = temp;

            i = Parent(i);

        }

    }

All the fields on your minHeap type are static. So yes: they're shared - that's what static means. You probably want to make them non-static.

Possibly you used static when you meant readonly?