temp-webapi-monolith-architecture VS SortingNetworks

On a side-note: I did an experiment to see whether C# could match C++ for vector-intensive computing: https://github.com/zvrba/SortingNetworks

Here's a concrete example of using pointers to access raw array memory and use SIMD intrinsics: https://github.com/zvrba/SortingNetworks

And now, for the fun of it, you can try with sorting. I've already done the hard work in C# (AVX2 intrinsics): https://github.com/zvrba/SortingNetworks

> I can't read C#

Not much different than C++...

> Do you generate the sorting network at compile time

No, except for power of two sizes up to 32. I experimented with run-time code generation (and compilation) for given sizes, but... the generated machine code has too long prologue and epilogue for that to be worth-while (though the sorting code itself is well optimized, as if directly compiled from source). That's also mentioned in "Benchmarks" section.

> What's your sorting network template?

See References.

> And probably related: how is vectorization used?

See the code. There's no template, the code is fully "dynamic" and adapts itself to array size. As for vectorization... it compares/swaps 8 ints/floats at once, with some swizzles to rearrange the elements. For sizes that are not power of 2, I use masked loads and stores and some extra logic for deciding which comparisons to skip. (I treat non-existing elements "as if" they were set to intmax or float infinity.)

This file https://github.com/zvrba/SortingNetworks/blob/master/Sorting... has it all.

> this week-end project

Sorry, can't read Rust. (Though it reminds me of days spent coding in Perl.) Most networks are not SIMD-friendly and the code as it's now is the 3rd iteration where I figured out how to best leverage SIMD to exploit the recursiveness and regularity in the network. (Not the least, no random memory accesses: only forward and backward loads and stores.)

Without SIMD, I don't think it'll be worth it, because network will also access the memory randomly (just as "standard" sort), and in addition it has worse algorithmic complexity.

So recently I posted a link with code for fast sorting of int arrays. People wondered how they'd perform for large arrays (1M elements), and I conjectured they'd be way slower because of their algorithmic complexity. Turns out I was wrong, they're 3-6x faster for arrays of length up to 1M elements. Updated code and benchmarks are now available at https://github.com/zvrba/SortingNetworks

The code (MIT license) is available here: https://github.com/zvrba/SortingNetworks