Automatically stackalloc array allocations if they are assigned to a Span

[pakrym]

Considering that we know that allocated memory would not leave the stack JIT could optimize the following cases:

1. When using a const as array size allocation can be turned into a stackalloc if it meets some predefined threshold for safe stackallocs.

Span<byte> bytes = new byte[20];
// ->
Span<byte> bytes = stackalloc byte[20];

Span<byte> bytes = new byte[2000];
// -> is not transformed because doesn't meet the threshold
Span<byte> bytes = new byte[2000];

2. For dynamic array sizes condition might be transformed into an intrinsic:

Span<byte> bytes = new byte[lenght];
// ->
Span<byte> bytes = maybe_alloc_stack_bytes(lenght);
// where maybe_alloc_stack_bytes would be equivalent to lenght <= MAX_STACKALOC ? stackalloc byte[lenght]: new byte[lenght]

@jkotas @AndyAyersMS @davidfowl @KrzysztofCwalina

category:cq
theme:stack-allocation
skill-level:expert
cost:large

[EgorBo]

https://github.com/dotnet/coreclr/issues/20253 - I guess it's enable stack allocation of constant-sized arrays in the list.

[Tornhoof]

There is also https://github.com/dotnet/corefx/issues/27985 in corefx by @GrabYourPitchforks

[AndyAyersMS]

Do you have a specific instance in mind that you can link to? Our ability to prove that

allocated memory would not leave the stack

is currently fairly limited.

cc @erozenfeld

[pakrym]

Do you have a specific instance in mind that you can link to?

An instance of what? Usages that might benefit from this?

For example: https://github.com/aspnet/AspNetCore/blob/master/src/Servers/IIS/IIS/src/Core/IO/AsyncWriteOperationBase.cs#L36

Our ability to prove that allocated memory would not leave the stack is currently fairly limited.

Doesn't using Span<T> guarantee that?

[tannergooding]

Doesn't using Span<T> guarantee that?

There are APIs that allow you to get the underlying ref from a Span<T>, so while the Span<T> itself shouldn't leave the stack; the underlying ref still could.

[pakrym]

Sure, but that is true for stackalloc-ed spans too.

[tannergooding]

Sure, but that is true for stackalloc-ed spans too.

The difference is that returning a pointer to the current method's stack is bad/unsafe.

Allocating an array, and indirectly returning a ref to it outside the current scope; while unlikely, is completely valid to do, provided you keep it as a ref the entire way through.

The compiler even lets you do this in trivial cases (sharplab):

public ref int Test()
{
    Span<int> x = new int[5];
    return ref x[0];
}

[jkotas]

Related to: dotnet/csharplang#1344 (comment)

[pakrym]

@tannergooding

I see. I didn't know that the sample you provided is allowed.

[benaadams]

Would that be an item for COMPlus_JitObjectStackAllocation=1 https://github.com/dotnet/coreclr/issues/20253

/cc @erozenfeld

[benaadams]

#11192 - I guess it's enable stack allocation of constant-sized arrays in the list.

@EgorBo snap; though I had lots of lag :)