That would be 5 measurements out of 100?

With the tiny tiny benchmarks game programs startup and warmup and shutdown costs must effect measurements longer than 1s -- but less so.

https://benchmarksgame-team.pages.debian.net/benchmarksgame/...

Here reverse-complement and spectral-norm have >25% difference. When you look at the main comparison table for either, it might seem that C# lags behind natively compiled languages, but if you look at the NAOT numbers - it is right there next to them.

So I'm putting a disclaimer because of it.

https://benchmarksgame-team.pages.debian.net/benchmarksgame/...

Not really. You don't have the same level of control over memory in managed languages

- structs, with auto, sequential and explicit layout, with complex SROA and promotion handling

- stack-allocated buffers, unsafe fixed and inline arrays, even managed objects can have their layout configured

- monomorphized struct generics compiled the same way they do in Rust

- raw and byref pointers with pointer arithmetic

- portable and platform-specific SIMD, platform-specific intrinsics

- zero-cost interop which enables calls into malloc/free at the cost of C/C++ (you do not actually need this - there is a managed reimplementation of mimalloc which is fully competitive with the original)

- static linking with native dependencies when using nativeaot

Here's a library that does this in C in case you are wondering: https://github.com/rxi/microui.

  // Please, just allocate a normal array instead, there is no benefit to this if it lives throughout the whole application lifetime
  var bytes = (stackalloc byte[512 * 1024]);

  // or, but, please, at least use a span instead of C nonsense of tracking offsets by hand
  // it's not 1980 anymore
  var ptr = stackalloc byte[512 * 1024]; // byte*

  // or
  [InlineArray(256 * 1024)]
  struct CommandList { byte _; }

  var commands = new CommandList();

  // or
  unsafe struct State
  {
    public fixed byte CommandList[256 * 1024];
  }

To avoid running into stack space limitations, you can place a fixed buffer or any of these large arrays into a static field. It gets a fixed static offset in the memory.

C# goes much further and also provides zero-cost abstractions via struct generics with interface constraints. Or without - you can also apply pattern matching against a generic T struct and it will be zero-cost and evaluated at compilation (be it with RyuJIT or ILC (IL AOT Compiler)).