What are the dangers when creating a thread with a stack size of 50x the default?

I’m currently working on a very performance critical program and one path I decided to explore that may help reduce resource consumption was increasing my worker threads’ stack size so I can move most of the data (float[]s) that I’ll be accesing onto the stack (using stackalloc).

I’ve read that the default stack size for a thread is 1 MB, so in order to move all my float[]s I would have to expand the stack by approximately 50 times (to 50 MB~).

I understand this is generally considered “unsafe” and isn’t recommended, but after benchmarking my current code against this method, I’ve discovered a 530% increase in processing speed! So I can not simply pass by this option without further investigation, which leads me to my question; what are the dangers associated with increasing the stack to such a large size (what could go wrong), and what precautions should I take to minimise such dangers?

My test code,

public static unsafe void TestMethod1()
{
    float* samples = stackalloc float[12500000];

    for (var ii = 0; ii < 12500000; ii++)
    {
        samples[ii] = 32768;
    }
}

public static void TestMethod2()
{
    var samples = new float[12500000];

    for (var i = 0; i < 12500000; i++)
    {
        samples[i] = 32768;
    }
}