stackalloc | quick prototype for vector-like containers | 3D Printing library

Isn't an answer to "why"; however you could change it to a ternary operator slicing the result of the array assignment to a Span:

I decided to create my own binding for it.

You can't. Best thing you can do instead, write a DLL in C or C++ which uses AVX512, and consume the DLL from C#. If you try to export individual instructions from the DLL, the performance won't be good because memory access, and because pinvoke overhead. Instead, you should write larger pieces of functionality in C.

I really don't know what I did wrong here.

Your C function expects input pointer in rcx register, and returns result in zmm0 vector register.

Your C# function doesn't know about zmm0. The runtime allocates 64 bytes on stack for the return value, passes address of the return value buffer in rcx register, passes input pointer in rdx register, and expects the function to return the pointer passed in rcx in rax register.

The languages on two sides of the interop disagree about the calling convention, and your code crashes in runtime.

vzeroupper can help performance.

The L0007 thru L0018 lines are zeroing out the storage space used by the local variables.

The 0x7d847bd1f9ce value appears to be related to detecting stack overruns. It sets in a check value, and when the function is done it looks to see if that value has changed. If it has it calls a diagnostic function.

The function body starts at L002c. First it initializes your local ymm variables, then does the additions.

The lea at L004b is the allocation of t. The next instruction (L004f) is the Avx2.Store(t, ymm0); statement.

L0053 thru L0063 is the for loop. rax already has the value of t, ecx holds i, and edx holds r.

From L0065 to the end we have the return statement and function epilog. The epilog checks to see if the stack has been clobbered, does some cleanup, and returns to the caller.

As said in the comments, vectorization is hard for such aggregation use case. However, it does not mean SIMD is completely useless for your problem. Try this version (untested).

The main idea, this version saves 50% of random loads/stores spent updating the accumulators. It interleaves the accumulators in memory, uses 128-bit load/add/store instructions, and splits the result back into 2 C# arrays after it consumed all input values.

I had the same problem but only for the first XML that you mentioned ()

I found an answer that worked for me (Release configuration with linking set to Sdk Assemblies Only)

In the Android project properties, I enabled the "use incremental Android packaging system" checkbox under "Android Options." and that solved the issue.

I found the solution in this thread.

I'm not sure I understand what you're asking. All the same features you relied on in the first code example still exist when using Span.

The Read(Span) overload still returns the count of bytes read. And since the Span is not the buffer itself, but rather just a window into the buffer, you can update the Span value to indicate the new starting point to read additional data. Having the count of bytes read and being able to specify the offset for the next read are all you need to duplicate the functionality in your old example. Of course, you don't currently have any code that saves the original buffer reference; you'll need to add that too.

I would expect something like this to work fine:

Ultimately, you can't. It is a marker on the "local" that defines something as being fixed from the perspective of the JIT, so you need a "local" per fixed element, and the number of locals is determined at compile time, not runtime.

I suspect you would need a locally scoped fixed at the call-site when you need it for that individual inner-array - but that's not very problematic: fixed is a remarkably cheap way of pinning (it is literally just a reference copy on the stack, with the JIT knowing from context that it means "pinned")

That said: I suspect you might also be able to use spans here, and bypass the entire need to use fixed or pointers.

This seems oversimplified, like in practice you won't know that 9 is the value you're looking for. But since you hard-coded that in your source, maybe that's what you want.

You're on the right track with pcmpeqb to find exact matches for that element you're looking for. Then you just need to horizontally sum those matches:

In C and C++ languages the developer defines in which memory an object is going to be instantiated: stack or heap.
In C# you it is determined by the author of the data type.
You can achieve your goal using Span and pointers. https://docs.microsoft.com/en-us/dotnet/api/system.span-1?view=netcore-3.1.
But I would not recommend you to do that, because your code is not safe. Meaning that CLR gives you all the responsibility to manage it, at least clean the memory, when you do not need such object anymore. Usually the C# developers come to such tricks, when they want to optimise really big data collections, which allocates a lot of memory in the heap. If it is still what you are looking for - than, probably, C# is not the best option to use.
Even more, if you have a big collection and somehow you find the way how to put it in stack memory - you can easily face StackOverflowException.