Much faster C# version

[SmartK8]

https://pastebin.com/usbUgMjT

[Kinematics]

I added this to my comprehensive build. It is indeed much faster than the standard version, but a bit slower than the rawbits version over on PR#6 (6040 vs 6200). Multithreaded is similar (38600 vs 39000).

The ref struct is performant, but it makes it more difficult to run things since I can't put an interface on it (so it won't easily fit in with the rest of the version selection logic, and has to have its own functions).

Issues found:

• It starts the inner loop at factor + factorTimes2, when it should be starting at factor * factor.
• You run the outer loop until factor < q, instead of factor <= q.
• Releasing the array pool after finishing Run() means you can't get a count or display the results. Getting around that is a little clumsy, requiring a manual disposal method. There might be a cleaner method, but this works for now.

[SmartK8]

1. It's in the current version of C# implementation (factor*3)
2. It's in the current sources as well (factor < q)
3. Yeah, it's a trick you release the data, but keep the bits, the memory is still locked by the span, so you can actually see the results. It's legit though. :D

As to ref struct. That's not the performant part. Normally the span would be created inside Run and passed as parameter, I wanted to disturb the code to the least degree. It's the Span and inlining doing the work. I just wanted to show that C# can be fast, it just depends on your implementation. Check this version with class instead: https://pastebin.com/24rPztvk

[Kinematics]

factor*factor is a performance optimization, and has been implemented in the C++ code. There's no reason to use a deliberately slower version in the other implementations just because Dave hasn't made any updates to the C# code (and several pull requests fixing things to be more consistent between the implementations haven't been landed).

factor < q is an actual bug. For example, if you run it for primes under 1000, you'll get 169 primes instead of the accurate 168. This has been fixed in the C++ version and several of the other implementations.

Hmm. I thought I had checked the state of both data and bits, and saw both of them as having been reset back to their default values after releasing the memory back to the array pool. I'll have to double check.

I'll check the class version tonight. If it performs the same as the ref struct, I'll use it instead, since I can slap an interface on it and use my general runner code instead of custom runner code.

[SmartK8]

Yeah, I didn't care about other versions. I just copied C# and modified it. The class performs indeed the same, but I had to modify the code. It's a limitation of how this project is written rather than C# itself, so I ignored the "template".

[Kinematics]

I put together the class version, and it ended up even faster than the ref struct (probably my fault in the implementation): 820 us per loop vs 840 us per loop. I'll stick with the class version since it makes everything easier.

Also used it as the basis for a version that uses mod 6 arithmetic. Got that up to 9850 loops in 5 seconds. :)