如果使用Parallel.For，则为StackOverflow

Question

I'm currently trying to make a code, that will help to count efficient reactors set for game StarMade. I'm using recursive method to explore the 3d tree of elements and find all related groups. For ex. group - it's a cluster of elements, that stay close to each other. On picture something like this:

XOX
OOX
XXO

where O is nothing, and X is reactor (element). On this picture there are 3 groups of elements. [0,0], [2,0]-[2,1], [0,2]-[1,2] Another variant:

XXX
OOX
XXX

Here is only one group, because all elements stay close to each other. Here is my code:

 void CheckGroup(int x, int y, int z, Group group)
    {
        if(x >= maxz || x < 0 || y >= maxy || y < 0 || z >= maxz || z < 0)
        {
            return;
        }

        if (reactorsChecked[x, y, z])
        {
            return;
        }
        reactorsChecked[x, y, z] = true;
        if (reactors[x, y, z])
        {
            if (group == null)
            {
                group = new Group();
                group.MaxX = x;
                group.MaxY = y;
                group.MaxZ = z;
                group.MinX = x;
                group.MinY = y;
                group.MinZ = z;
                group.Blocks = 1;
            }
            else
            {
                group.MaxX = Math.Max(group.MaxX, x);
                group.MaxY = Math.Max(group.MaxY, y);
                group.MaxZ = Math.Max(group.MaxZ, z);
                group.MinX = Math.Min(group.MinX, x);
                group.MinY = Math.Min(group.MinY, y);
                group.MinZ = Math.Min(group.MinZ, z);
                group.Blocks += 1;
            }

            CheckGroup(x + 1, y, z, group);
            CheckGroup(x - 1, y, z, group);

            CheckGroup(x, y + 1, z, group);
            CheckGroup(x, y - 1, z, group);

            CheckGroup(x, y, z + 1, group);
            CheckGroup(x, y, z - 1, group);

            if (!groups.Contains(group))
            {
                groups.Add(group);
            }
        }
    }

group - is simple class for cluster, that store data about elements count in this cluster and bounding box of this cluster. reactorsChecked - is simple bool[,,] array, that store information about elements, that we have checked, to avoid doubles reactor - simple bool[,,] array of random elements. At first I insert random values to reactors array, and then call CheckGroup(x,y,z,null). If reactors array size less then 25x25x25, then all ok. In single thread size of array could be 100x100x100 and all would be ok. But if I try to use Parallel.For, then I got StackOverflow after near 9000 recursions... Here is full code:

Parallel.For(0, Environment.ProcessorCount, (i) =>
            {
                Calculator calc = new Calculator(x, y, z, max, cycles);
                calcs.Add(calc);
            });

public class Calculator
{
    Random rnd = new Random();
    //List<Group> groups = new List<Group>();
    HashSet<Group> groups = new HashSet<Group>();
    bool[, ,] reactors;
    public bool[, ,] reactorsMax;
    bool[, ,] reactorsChecked;
    public double maxEnergy = 0;
    public string result = "";
    public string resultPic = "";

    int maxx, maxy, maxz;

    public Calculator(int x, int y, int z, int max, int cycles)
    {
        maxx = x;
        maxy = y;
        maxz = z;
        maxEnergy = max;
        for (int i = 0; i < cycles; i++)//check few variants per thread
        {
            Calculate(x,y,z);
        }
    }

    private void Calculate(int X, int Y, int Z)
    {
        //groups = new List<Group>();
        groups = new HashSet<Group>();

        reactors = new bool[X, Y, Z];

        for (int x = 0; x < X; x++)
        {
            for (int y = 0; y < Y; y++)
            {
                for (int z = 0; z < Z; z++)
                {
                    reactors[x, y, z] = rnd.Next(2)==1;//fill array with random values
                }
            }
        }

        reactorsChecked = new bool[X, Y, Z];
        for (int x = 0; x < X; x++)
        {
            for (int y = 0; y < Y; y++)
            {
                for (int z = 0; z < Z; z++)
                {
                    CheckGroup(x, y, z, null);//start calculations
                }
            }
        }
        double sum = 0;
        int blocks = 0;
        foreach(Group g in groups)
        {
            float dims = g.MaxX - g.MinX + g.MaxY - g.MinY + g.MaxZ - g.MinZ + 3;
            sum += (2000000.0f / (1.0f + Math.Pow(1.000696f, (-0.333f * Math.Pow((dims / 3.0f), 1.7)))) - 1000000.0f + 25.0f * g.Blocks);
            blocks += g.Blocks;
        }

        if (sum > maxEnergy)
        {
            maxEnergy = sum;

            reactorsMax = reactors;
        }

    }

    void CheckGroup(int x, int y, int z, Group group)
    {
        if(x >= maxz || x < 0 || y >= maxy || y < 0 || z >= maxz || z < 0)
        {
            return;
        }

        if (reactorsChecked[x, y, z])
        {
            return;
        }
        reactorsChecked[x, y, z] = true;
        if (reactors[x, y, z])
        {
            if (group == null)
            {
                group = new Group();
                group.MaxX = x;
                group.MaxY = y;
                group.MaxZ = z;
                group.MinX = x;
                group.MinY = y;
                group.MinZ = z;
                group.Blocks = 1;
            }
            else
            {
                group.MaxX = Math.Max(group.MaxX, x);
                group.MaxY = Math.Max(group.MaxY, y);
                group.MaxZ = Math.Max(group.MaxZ, z);
                group.MinX = Math.Min(group.MinX, x);
                group.MinY = Math.Min(group.MinY, y);
                group.MinZ = Math.Min(group.MinZ, z);
                group.Blocks += 1;
            }

            CheckGroup(x + 1, y, z, group);
            CheckGroup(x - 1, y, z, group);

            CheckGroup(x, y + 1, z, group);
            CheckGroup(x, y - 1, z, group);

            CheckGroup(x, y, z + 1, group);
            CheckGroup(x, y, z - 1, group);

            if (!groups.Contains(group))
            {
                groups.Add(group);
            }
        }
    }

}

So the main question - is it possible to avoid stackOverflow in Parallel.For, or to rewrite it to iteration loop?

Parallel.For using default stackSize value even if you will use

Thread(()=>
{
    Parallel.For(...);
},stackSize).Start()

it will use default values...

I don't like variant like this:

for(int i = 0; i < cpuCount; i++)
{
    Thread t = new Thread(()=>{calculate();},stackSize).Start()
}

because I have to manage all threads, wait while all finishes, so it makes code very complicated... May be there are easier things?

Answer 1

There are two options:

1. to use recursion and try to increase the stack size (by using the Thread(ThreadStart, maxStackSize) constructor). The stack in applications is usually set to 1MB (see this link for details). Especially in DEBUG mode without optimizations (no inlining optimization done) this is a very limited value. Having a thread with separate stack for every Paralllel.For() statement might help.

2. Use a iteration look instead of recursion to handle the stack depth by yourself.

I personally would go with option 1. (with or without separate stack) only in case I known the maximum depth of my recursion.

My preferred solution in most cases like yours will be the iteration approach.

Edit by @LordXaosa: I tried this, and all works fine

int stackSize = 1024*1024*1024;//1GB limit
ManualResetEvent[] mre = new ManualResetEvent[Environment.ProcessorCount];
Parallel.For(0, Environment.ProcessorCount, (i) =>
{
     mre[i] = new ManualResetEvent(false);
     Thread t = new Thread((object reset) =>
     {
           Calculator calc = new Calculator(x, y, z, max, cycles);
           calcs.Add(calc);
           ManualResetEvent m = (ManualResetEvent)reset;
           m.Set();
     }, stackSize / (Environment.ProcessorCount * 4));
     t.Start(mre[i]);
});
WaitHandle.WaitAll(mre);

But there also a limit... 50x50x50 array works fine, but more - stack overflow... In original game it can process 1000x1000x1000 sets, so may be there is another algorithm. Thanks for your help!