Fast CPU Points Generation Library

Yo! I just wrote a C library that showcases how to use libsecp256k1 for super quick batch additions. It can scan a specified range from start to end really fast. You can stream the generated points or use it to test your CPU's performance. Check it out on GitHub!

Sounds interesting! How does it actually work?

Just set a start point, define a size, and pick the number of threads. The rest is all magic! It uses only two EC point multiplications, so it’s efficient. To generate a billion points, it’s crazy fast.

I bet some people are gonna spend days breaking down that code.

Results on my old Ryzen 7 5800H: Using 16 threads, I’m hitting about 42.63 million keys per second. Sure, it’s slower than your i9 by 45-50%, but still pretty decent! Have you tried RELIC? I think it’s faster than libsecp256k1.

Wait, what does your code actually do? How does it fit into this whole discussion?

This library is all about generating all affine points in a specific range. I’m not clear on what your code does though.

Appreciate the code! Just skimmed it on my phone. Is it just batch inverse and additions? I think I have an OpenCL version that does something similar. I’ll benchmark it on my 7950X.

Definitely! The inversion tree is parallelized, allowing SIMD optimizations. Field multiplications can run in parallel, making it quicker to create and break down the inverses.

Awesome! I have some ideas to improve it. You could precompute neg(x1) outside the loop, saving some operations. Might help speed things up a bit.

You’re spot on! That would save a few operations. And yeah, small optimizations can make a difference. I also forgot to add -march=native for native CPU instructions. Gonna fix that.

But what’s the main point of this code? How exactly are the X points stored?

It’s about fast point generation across the entire range. Check db.c for how the X coordinates are stored. They’re saved as little-endian bytes, with an integer key offset. What did you expect?

So is it all in one file? How do I even run this? I know C++ and Python, but C is a whole different beast.

Compile it according to the README. You can manipulate the database however you want, just treat the values as offsets. The code is stable, but watch out for specific edge cases I’ll fix.

I cleaned up some ops in a separate branch: Pre-computed negated x2. Still, speed fluctuates too much to notice a difference.

But what’s the database structure? If it’s all in one file, isn’t that gonna slow down lookups?

If a single file with a B*-tree structure has no advantage for lookups, I’m not sure what does. Maybe a ton of text files and linear searches?

Haha, yeah right! You can do what you want with the generated points. But storing everything on disk isn’t optimal either.

How much RAM do we need for 2^30 points? And what GPUs could keep operation speeds instant?