Quote from: RetiredCoder on November 08, 2024, 09:17:40 AM

Quote from: kTimesG on November 08, 2024, 08:53:52 AM

Powers of two, and adjust the last element to the value needed to have the desired average.
This jump set was proven optimal here (e.g. minimizes total number of operations):
Kangaroos, Monopoly and Discrete Logarithms, J. M. Pollard, 2000

Well, ok. But I use fixed length table for all tests, it's more practical for implementation, also I get better results for longer list than using powers of two.
I will try your approach to see results.

Quote from: kTimesG on November 08, 2024, 08:53:52 AM

Question for you: do you prefer fewer kangaroos that jump faster, or lots of kangaroos that jump slower?

I prefer faster kangs because of high DP bits that I have to use to solve high puzzles, to get smaller overhead. But even so, the number of kangs is crazy because there are many GPUs and every GPU has a lot of kangs anyway.

Quote from: kTimesG on November 08, 2024, 08:53:52 AM

How can you explain case #3 (the awful case with runtime 172 sqrt)? When the Tame and Wild are separated by a distance of b/2, and the average jump size is much too small, it will take a lot of jumps for them to ever meet. In the random case, it's a little better than that, but still too far from the optimal case (e.g. a correct larger average jump size).

Main question here is how many times do you solve a point to calculate average result value? In my tests I solve at least 1000 times.

Quote

I never understodd why JLP and the clones leaned towards squeezing more kangaroos into GPU memory; it slows down everything, instead of speeding things up. Lower throughput, lower speed/kang, and a really high DP overhead.

Like what are y'all even talking about here? You prefer faster kangaroos versus more, slower kangaroos...ok, what's the sweet spot? What bit range? What DP is used?

All of these play a factor...I don't think you can say x y z is always better.

Isn't this a super easy task, to test? Give me the same program, and I will run it with a GPU and then with a CPU, and let's see which solves the key first. Let's make it an 80 bit range. 1 GPU versus a single core, or do you want to use as many cores as the CPU has? Any bets on which one finds the key first?
Also, RetiredCoder, make mods to the program, to create less "kangs" when using a GPU, if it's to crazy for you...it's super easy to do. And another question, how does the speed of "kangs", impact the finding of High DP bits. Does a CPU (which the individual kangs are faster) find high DP bits, faster? Or does the GPU's slow, but many, find more, DP bits, faster?
And the last question, which "high puzzles" have you solved and what did you use to solve (CPU, GPU, DP, etc)