GPU support wanted / relevant?

[sesam]

I see no mention of GPU support, if it's relevant, PRs wanted, etc.

Here's another ed25519 vanity generator that might be interesting to compare with: https://docs.rs/crate/nano-vanity/0.2.1

[cathugger]

There was #4 but basically I don't really have hardware to test with and much experience with programming GPUs :\
And I'm not really sure how it'd integrate with stuff like filters, and is this project right scope for that.
Thanks for mentioning https://github.com/PlasmaPower/nano-vanity looks like it's doing pretty much same kind of thing.
Should we filter inside GPU? Or send all generated keys to CPU for that? Or mixed approach with subset of wider filters in GPU and full filtering in CPU side?
How should it relate to main mkp224o application? Be part of it, or separate executable? (probably separate, different kind of dependencies)
mkp224o is CC0 (with some parts put into Public Domain), but since https://github.com/PlasmaPower/nano-vanity is BSD, and I don't think it's worth redoing it, that part of codebase would be BSD licensed.
Should it be in this project scope, or separate repository should be made? Not sure..

Lot of uncertainty from my side... I'll need to think about it, but I myself currently not doing any code for this, so incase anyone wants to work on it, they shouldn't hesitate.

[Cyclic3]

Have you tried pocl? That works with just a CPU, so you should be able to test with it.

[Baaleos]

In regards to the question of when to do the filtering - Scallion - a .net GPU generator for onion addresses I think just generates a work load, processes the GPG keys and then filters on the cpu.
The important thing is to keep the GPU hard at work, if it runs out of work it then throttles down.

[cathugger]

I'm too busy with other irl stuff, and have too little interest in doing this myself (lack of actual powerful GPU isn't motivating, because I personally won't benefit from it, and even testing might get unnecessarily tedious (unless I try with pocl but that's one more thing to learn to play with..)).
Will leave open, as there is some good knowledge in this issue in case someone might be interested doing this.

[exander77]

Is here a documentation how are the new adresses generated?

[cathugger]

currently no but reading code shouldn't be hard.
essentially we generate ed25519 pubkeys as quick as possible filtering them as quickly as possible and once we get match we reseed private key, and format pubkey x privkey pair in format tor accepts and dump that to filesystem. or output in yaml-ish format.
there are few ways to calculate public keys as quick as possible.
there are also few ways to filter and it depends on amount of filters and their properties which way to do it works best. which is why it's configurable at compile time.

[cathugger]

@whalehub It'd increase likehood. But then I don't even have proper motherboard for that (my only serious working machine right now is laptop). Might get some better hardware this summer, maybe.
Why is nobody who isn't me doing it, tho, I mean there definitely must be people capable and having all the right hardware, and it shouldn't even be too hard. There's even https://github.com/PlasmaPower/nano-vanity/blob/master/src/opencl/curve25519.cl, also there are useful tips in https://eprint.iacr.org/2014/198.pdf.

[Scripter17]

I don't mean to be rude, but has anyone made any progress on this front? I can't find any other software that does what the issue proposes.
It's been a bit over a year and a half since this issue started, and just a few days over a year since the last comment. I highly doubt that no one has done anything with this in that time.

[cathugger]

as I've indicated earlier I'm not working on it atm.
it kinda looks a bit odd to me too that no one's doing it.

[dr-bonez]

I have built one that works with cuda in Rust.
https://github.com/dr-bonez/tor-v3-vanity

[GIJack]

I could definitely use some OpenCL support. Especially multi-device...

I have two GPUs and would make my life easier...

[harryqt]

@dr-bonez which is would be better? AMD 5900x CPU or RTX 3080 GPU?

[dr-bonez]

There's definitely something wrong with my generator that is slowing it down, that I haven't had time to debug. For now, I'd recommend continuing to use the cpu version.

[harryqt]

Alright. Thank you. 🙏

[mooleshacat]

Why is nobody who isn't me doing it, tho, I mean there definitely must be people capable and having all the right hardware, and it shouldn't even be too hard.

I have the hardware, just no clue how and I suck at programming. Very limited in programming ability. But I'd say 5950x w/ RTX 3070 is more than enough.

If anyone does code this and need testing let me know :) I'd be glad to test (and use when done)

[adapt-L]

I think I still have some code saved from last year when I attempted this with OpenCL. It was very inefficient, orders of magnitude slower than mkp244o (perhaps because it was a copy of supercop or donna that used branching)? This was just a test on intel graphics though, I have not been able to get OpenCL working on amd or nvidia.

I can share if anyone is interested. Maybe someone with OpenCL experience could fix it up...

[cathugger]

please do share. i kinda do have capable setup now, just not much time. even if not for me, may be useful for someone else.

[exander77]

I think I still have some code saved from last year when I attempted this with OpenCL. It was very inefficient, orders of magnitude slower than mkp244o (perhaps because it was a copy of supercop or donna that used branching)? This was just a test on intel graphics though, I have not been able to get OpenCL working on amd or nvidia.

I can share if anyone is interested. Maybe someone with OpenCL experience could fix it up...

Yes, if you share it, We can definitely optimize. I hate interfacing with OpenCL, but I can look into optimizing already existing code.

[adapt-L]

@exander77 Here is a link: https://github.com/adapt-L/GenEd
It's just a prototype that generates the keypair and filters it. My CPU (i5-1240P) gives me 0.28676 million keypairs/sec and my integrated GPU gives me 0.0614793 million keypairs/sec