stackalloc return

[MkazemAkhgary]

is stackalloc return possible? it would be used to prevent creating array on heap, array would be created on stack and its pointer is returned, (or maybe copied in stack once its popped?)

stackalloc byte* GetBytes();  // array remains on stack
byte[] GetBytes(); // array will be stored on heap

[HaloFour]

Normal arrays can only be allocated and stored on the heap.

If GetBytes were to allocate a block of memory on its stack by the time that function returns that stack space would be no longer accessible. The caller of GetBytes would have to allocate the memory on its own stack space beforehand, which would kind of defeat the purpose.

[MkazemAkhgary]

Yes, that's what I thought too. if stack is popped then array will be lost. that's why I mentioned it maybe copied before its returned? for example a pointer would be passed and on top of stack, before returning array will be copied there, so once you pop you have the array. I guess this is possible with c#7 which introduces ref locals/returns.

@HaloFour

[HaloFour]

@MkazemAkhgary

for example a pointer would be passed and on top of stack, before returning array will be copied there, so once you pop you have the array.

The only way that would work (in any language) is if the caller were to preallocate a block of memory and pass a pointer to the function. You can do that today in C#. With ref parameters, ref returns and the upcoming ref-like Span<T> types there are a number of options that will help writing performance-sensitive code like this.

[Jure-BB]

What about inlined functions? Would it be possible to write a small function marked as always inlined which would preallocate a block of memory on the stack?

First, it would pass Span to the function with an implementation which would fill Span with result. Second, it would return stack allocated Span. Since it would be always inlined, it would be guaranteed that stackalloc happens locally in the caller.

[MethodImpl(MethodImplOptions.AlwaysInline)]
Span<byte> A(...)
{
    Span<byte> target = stackalloc byte[16];
    AImpl(target, ...);
    return target;
}

This would help to encapsulate preallocating memory to a correct size.

[MkazemAkhgary]

I see, so that requires size of array to be known before calling method. then I guess it should be like this.

stackalloc[10] byte* GetBytes(); // preallocate block of memory with size of 10.

with a little twist

stackalloc[x] byte* GetBytes();

byte* arr = stackalloc[20] GetBytes();

@HaloFour

[HaloFour]

@MkazemAkhgary

Yes, but then the function needs to accept that pointer so that it can write to it. At that point you might as well allocate and pass the byte* or Span<T> or whatever as a proper parameter to GetBytes. That would be faster than requiring a second allocation and a copy anyway.