SortingNetworks VS ASP.NET Core

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

> Just .GetAwaiter().GetResult() it.

That won’t work with various synchronization contexts, where doing this would cause a deadlock. There’s not much fun in trying to debug such issues.

And now that various libraries only provide async api, or worse an non-async version wrapping the async one with . GetAwaiter().GetResult(), you’ll be in for a treat updating your dependencies.

Async all the way is the answer, although various frameworks still don’t offer async hooks. Recently I ran into this for example trying to write an async validator in blazor, but that’s not possible and you have to work around it [1].

C# 5 introduced async/await almost 12 years ago. And we’re still not “async all the way”.

[1]: https://github.com/dotnet/aspnetcore/issues/40244

This approach to organizing middleware enhances code readability, maintainability, and reusability. By following this encapsulation pattern, you're adhering to best practices in ASP.NET Core development, ensuring your application remains well-organized and scalable.

🌟.NET 9 Preview 2 ➡️.NET 9 Preview 2 Discussion ➡️ASP.NET Core updates in .NET 9 Preview 2 ➡️ASP.NET Core updates in .NET 9 Preview 2 Release Notes ➡️EF Core updates in .NET 9 Preview 2 ➡️.NET Aspire preview 4 - .NET Aspire

https://github.com/dotnet/aspnetcore/issues/50643

Even if you look at Microsoft’s by far most popular GitHub project, they’re still only half as big as SupaBase. If you believe “the SupaBase story”, SupaBase grew and became twice as large as Microsoft in 3 years. Below is their likes over time if you’re curious, together with a couple of additional “too good to be true” Silicon Valley projects.

https://github.com/dotnet/aspnetcore/issues/10117

To achieve these objectives, we will take inspiration from ASP.NET Core Identity's PasswordHasher class. It incorporates a concept of hash versioning, allowing only the number of iterations to be modified.

yes I watched several courses, may be aim not getting clearly. but i worked with asp.net which uses http call and firebase cloud function also which uses socket connection, for socket connection its makes sense to use observable bcoz there streams of data we can observe once the connection establish ,but for http it need to be call every time.