Proposal: Add a new keyword "trystackalloc" to prevent stack overflow

[ygc369]

It should only be used with Span. If there's no enough space on stack, it should return an empty Span, instead of throwing exception. For example:

Span<int> sp = trystackalloc int[1000];
if(sp.Length==0) sp = new int[1000];
......

[svick]

Related proposal: https:/dotnet/corefx/issues/26954. With that, your code would probably look like this (though this exact pattern is not currently supported by the compiler, see dotnet/roslyn#25118):

Span<int> span = stackalloc int[0];
if (RuntimeHelpers.TryEnsureSufficientExecutionStack(1000 * sizeof(int)))
    span = stackalloc int[1000];
else
    span = new int[1000];

I feel like adding a method is a better solution here: trystackalloc couldn't work without CoreCLR or CoreFX support anyway and this code doesn't need to be super-succinct.

[jkotas]

These are two specialized constructs that do not address the scenario well. The scenario is allocation of a local scratch buffer of variable size. We need a construct that does that, without exposing the ugly details on how it is done underneath. It should automatically allocate inline from the stack when it the requested buffer is small, and from the pool when the requested buffer is large.

E.g. it can look something like this:

using (var localBuffer = new LocalBuffer<byte>(1000))
{
     Span<byte> span = localBuffer.AsSpan();
...
}

[svick]

@jkotas If such abstraction is possible and can work well, then yeah, that would be a better option.

Though I have a hard time imagining how that would work both on the inside (how is LocalBuffer<T> implemented?) and on the outside (does the C# compiler treat LocalBuffer<T> in a special way? I guess it would be similar to ref-like types).

[ygc369]

@jkotas
I agree with you, but I wonder how could LocalBuffer constructor return a buffer on stack, because any buffer allocated on stack within the construcor would be released after executing the constructor.

[jkotas]

The portable implementation of LocalBuffer can look like this:

public ref struct LocalBuffer<T>
{
    T[] _arrayToRelease;
    int _size;
    fixed long _data[32];

    public LocalBuffer(int size)
    {
        if (RuntimeHelpers.IsReferenceOrContainsReferences<T>() || size > 32*sizeof(long)/Unsafe.SizeOf<T>())
            _arrayToRelease = ArrayPool<T>.Shared.Rent(size);
    }

    public Span<T> AsSpan() => (_arrayToRelease != null) ? new Span<T>(_arrayToRelease, 0, _size) : new Span<T>(&_data, _size);

    public void Dispose()
    {
        if (_arrayToRelease != null)
             ArrayPool<T>.Shared.Return(_arrayToRelease);
    }
}

This won't actually compile. You have to sprinkle with workarounds for the current C# language limitations to get it to compile, but you should get the idea.

This can be further improved by treating LocalBuffer as runtime intrinsic type. It would allow allocating the object reference-containing buffers on the stack as well, etc.

[svick]

@jkotas I think that implementation does not really replace TryEnsureSufficientExecutionStack, since it won't allocate a medium-sized (say 4kB) buffer from the stack and also won't actually check that there is sufficient space on the stack for the buffer.

Are you saying the intrinsic version could do that?

[jkotas]

Yes, the intrinsic version can do that. More importantly, the intrinsic version allows runtime to pick the right threshold for you based the performance data. E.g. the threshold can differ between platforms, or for types that contain GC references and types that to not contain references.

Also, I believe that the threshold for where it stops being worth it to allocate the buffers on the stack is pretty small, probably in the hundreds of bytes range. Once the max stackallocated buffer is this small, checking for sufficient space on the stack is not really a concern.

[svick]

I have opened a somewhat related issue: #1817 stackalloc from caller's stack frame. If that was implemented, it would be possible to write a method that takes into account any number of factors (the size of the required buffer, TryEnsureSufficientExecutionStack, …) and then uses the best choice for how to allocate the buffer (stackalloc, new, ArrayPool, …) and finally returns it as a Span<T>.

[YairHalberstadt]

There's a proposal to handle this purely by adding a runtime API: dotnet/runtime#25423