Akito S. M. Hosana
Jr. Member
 Offline
Activity: 420
Merit: 8
|
 |
April 04, 2025, 10:44:45 PM |
|
Is this a new trend now? Everyone is dealing with mutations? I thought I was in the wrong forum – that it was for genetics.  |
|
|
|
|
Dom1nic
Newbie
Offline
Activity: 20
Merit: 0
|
|
April 05, 2025, 12:12:28 AM |
|
With all this code, my coding skills went from 0 to almost 0.5  |
|
|
|
|
Bram24732
Member
Offline
Activity: 322
Merit: 28
|
|
April 05, 2025, 08:22:19 AM |
|
1. I still cannot understand how and why this work...can you elaborate on this please?
2. what do you mean by "At least I know that if you have the correct base key for the right bit flip?
thanks
Python code: xor_masks = {
67: 0b1100111100000011110111001010001111100110101111010011111001010001,
66: 0b10111110011010001001010001011000011010100101000011100101000010001,
65: 0b101011111000111010011101100101011111010010011011001011110011000,
64: 0b100011111010111000001101100001001111011011101110110100101011,
63: 0b1100110001101000010000001001010011001100001001011111110111,
62: 0b100111000010101010111110000101001001111011100101010000010001,
61: 0b110000110110100101011100100010111101000010011011011011111001,
60: 0b111111100001011110011111011010110010011000010001000001,
59: 0b10110110100100110100010001111000001101010100101110110000,
58: 0b100111001100010100100011110101101111001110110010111011110,
57: 0b10100110110100011011011111000011010100010100111100011,
56: 0b1100010111001110100100111000101001110110000000000100000,
55: 0b10101010000011110000001100100100110000001111011101011,
54: 0b11100100100000100100100101010010100101110000010111100,
53: 0b111111110000111011100011011100000011100110110010011,
52: 0b1000001010001111010011011001101000110000111000011,
51: 0b101011111000111101011110010111111111011000101011,
50: 0b1110101000010101111000011110100010110110010101011,
49: 0b100010111110100010010100111111101010000010110010,
48: 0b10100100001100100101000001100011100010001100100,
47: 0b100110010100111101111010010101100001101000101,
46: 0b100010011111001111100011101110010101010111011,
45: 0b11011101000000110101111010111100001111111010,
44: 0b11111110101001100101001011100101001110000,
43: 0b10100001011000100110110000011101001101110,
42: 0b10101110111011110001110100111001001110000,
41: 0b1010110001111001011001010011001110100100,
40: 0b1011001010001101101101100110000101001,
39: 0b11010010100000011111001111110000010110,
38: 0b1110111000111110100000101001100101111,
37: 0b100010101000100010101001010101101100,
36: 0b11000100001011111011111010110000011,
35: 0b1101010001001011011110111010001111,
34: 0b10110101100110100110111011100010,
33: 0b1010110100100110101011100100111,
32: 0b1000111100111010101100111010001,
31: 0b10101100000001100010111000,
30: 0b10011010110011001010011011,
29: 0b1000000111011010101011100001,
28: 0b10011011101001001100010111,
27: 0b1010100111100011110001010,
26: 0b101111111100110110010001,
25: 0b1011010000100011010,
24: 0b1000111101010111111011,
23: 0b1010101001000110101101,
22: 0b100100001101111110000,
21: 0b1000101101011001011,
20: 0b101101001110101010,
19: 0b101000101101100000,
18: 0b1111011111110010,
17: 0b1000100110110000,
16: 0b11011011001001,
15: 0b1011100001100,
14: 0b1011011001111,
13: 0b101110011111,
12: 0b10110000100,
11: 0b1101111100,
10: 0b111111101,
9: 0b101100,
8: 0b11111,
7: 0b110011,
6: 0b1110,
5: 0b1010,
4: 0b111,
3: 0b0,
2: 0b0,
1: 0b0
}
def generate_private_keys():
print("Puzzle | Private Key")
print("-------------------")
for puzzle in range(1, 68):
if puzzle in xor_masks:
puzzle_end = 2**puzzle - 1
private_key = puzzle_end ^ xor_masks[puzzle]
print(f"{puzzle:6} | {private_key}")
else:
print(f"{puzzle:6} | (Missing XOR mask)")
generate_private_keys()Is it clearer now? If not, then nothing. Hi, still no understand why this works...and why it is more efficient than bruteforcing. The masks I suppose are the result of Mutagen? Can you take please two minutes to explain in full? also, "private_key = puzzle_end ^ xor_masks[puzzle]" is useless given that you xor the end of the range which is all 1s with the "mask", so in reality your "mask" is the opposite bits of the private key ALWAYS...meaning it gives you nothing! Thanks It’s not more efficient than brute forcing. It actually requires the exact same number of computations than brute force to scan the range. |
I solved 67 and 68 using custom software distributing the load across ~25k GPUs. 4090 stocks speeds : ~8.1Bkeys/sec. Don’t challenge me technically if you know shit about fuck, I’ll ignore you. Same goes if all you can do is LLM reply.
|
|
|
Akito S. M. Hosana
Jr. Member
Offline
Activity: 420
Merit: 8
|
|
April 05, 2025, 08:56:40 AM |
|
With all this code, my coding skills went from 0 to almost 0.5 Last time, we got to 96% of the code, and I ran out of comments in Deepseek (the final solution was deleted). I don't know which AI is the bigger idiot: Deepseek or ChatGPT? Or me using them. |
|
|
|
|
Dom1nic
Newbie
Offline
Activity: 20
Merit: 0
|
|
April 05, 2025, 09:10:17 AM |
|
1. I still cannot understand how and why this work...can you elaborate on this please?
2. what do you mean by "At least I know that if you have the correct base key for the right bit flip?
thanks
Python code: xor_masks = {
67: 0b1100111100000011110111001010001111100110101111010011111001010001,
66: 0b10111110011010001001010001011000011010100101000011100101000010001,
65: 0b101011111000111010011101100101011111010010011011001011110011000,
64: 0b100011111010111000001101100001001111011011101110110100101011,
63: 0b1100110001101000010000001001010011001100001001011111110111,
62: 0b100111000010101010111110000101001001111011100101010000010001,
61: 0b110000110110100101011100100010111101000010011011011011111001,
60: 0b111111100001011110011111011010110010011000010001000001,
59: 0b10110110100100110100010001111000001101010100101110110000,
58: 0b100111001100010100100011110101101111001110110010111011110,
57: 0b10100110110100011011011111000011010100010100111100011,
56: 0b1100010111001110100100111000101001110110000000000100000,
55: 0b10101010000011110000001100100100110000001111011101011,
54: 0b11100100100000100100100101010010100101110000010111100,
53: 0b111111110000111011100011011100000011100110110010011,
52: 0b1000001010001111010011011001101000110000111000011,
51: 0b101011111000111101011110010111111111011000101011,
50: 0b1110101000010101111000011110100010110110010101011,
49: 0b100010111110100010010100111111101010000010110010,
48: 0b10100100001100100101000001100011100010001100100,
47: 0b100110010100111101111010010101100001101000101,
46: 0b100010011111001111100011101110010101010111011,
45: 0b11011101000000110101111010111100001111111010,
44: 0b11111110101001100101001011100101001110000,
43: 0b10100001011000100110110000011101001101110,
42: 0b10101110111011110001110100111001001110000,
41: 0b1010110001111001011001010011001110100100,
40: 0b1011001010001101101101100110000101001,
39: 0b11010010100000011111001111110000010110,
38: 0b1110111000111110100000101001100101111,
37: 0b100010101000100010101001010101101100,
36: 0b11000100001011111011111010110000011,
35: 0b1101010001001011011110111010001111,
34: 0b10110101100110100110111011100010,
33: 0b1010110100100110101011100100111,
32: 0b1000111100111010101100111010001,
31: 0b10101100000001100010111000,
30: 0b10011010110011001010011011,
29: 0b1000000111011010101011100001,
28: 0b10011011101001001100010111,
27: 0b1010100111100011110001010,
26: 0b101111111100110110010001,
25: 0b1011010000100011010,
24: 0b1000111101010111111011,
23: 0b1010101001000110101101,
22: 0b100100001101111110000,
21: 0b1000101101011001011,
20: 0b101101001110101010,
19: 0b101000101101100000,
18: 0b1111011111110010,
17: 0b1000100110110000,
16: 0b11011011001001,
15: 0b1011100001100,
14: 0b1011011001111,
13: 0b101110011111,
12: 0b10110000100,
11: 0b1101111100,
10: 0b111111101,
9: 0b101100,
8: 0b11111,
7: 0b110011,
6: 0b1110,
5: 0b1010,
4: 0b111,
3: 0b0,
2: 0b0,
1: 0b0
}
def generate_private_keys():
print("Puzzle | Private Key")
print("-------------------")
for puzzle in range(1, 68):
if puzzle in xor_masks:
puzzle_end = 2**puzzle - 1
private_key = puzzle_end ^ xor_masks[puzzle]
print(f"{puzzle:6} | {private_key}")
else:
print(f"{puzzle:6} | (Missing XOR mask)")
generate_private_keys()Is it clearer now? If not, then nothing. Hi, still no understand why this works...and why it is more efficient than bruteforcing. The masks I suppose are the result of Mutagen? Can you take please two minutes to explain in full? also, "private_key = puzzle_end ^ xor_masks[puzzle]" is useless given that you xor the end of the range which is all 1s with the "mask", so in reality your "mask" is the opposite bits of the private key ALWAYS...meaning it gives you nothing! Thanks It’s not more efficient than brute forcing. It actually requires the exact same number of computations than brute force to scan the range. Yup, even with my skills, it’s obvious that the total number of bit combinations is the same as the keys in the puzzle. So I’ll probably use this approach when choosing the sub-ranges I’m scanning: start from the previous range, apply the mutagen to that string. If the key is found before 50% of the 50% expected in random mode, then we can start talking about efficiency. |
|
|
|
|
Akito S. M. Hosana
Jr. Member
Offline
Activity: 420
Merit: 8
|
|
April 05, 2025, 09:27:10 AM |
|
Yup, even with my skills, it’s obvious that the total number of bit combinations is the same as the keys in the puzzle. So I’ll probably use this approach when choosing the sub-ranges I’m scanning: start from the previous range, apply the mutagen to that string.
If the key is found before 50% of the 50% expected in random mode, then we can start talking about efficiency.
Maybe they have something up their sleeve that they haven't shown publicly yet—some kind of filtering XOR masks or something more complex that might work. Anyway, maybe it's just a more elegant way to achieve the same thing, though not necessarily faster than other solutions. |
|
|
|
|
AlanJohnson
Member
Offline
Activity: 185
Merit: 11
|
|
April 05, 2025, 10:02:35 AM |
|
Yup, even with my skills, it’s obvious that the total number of bit combinations is the same as the keys in the puzzle. So I’ll probably use this approach when choosing the sub-ranges I’m scanning: start from the previous range, apply the mutagen to that string.
If the key is found before 50% of the 50% expected in random mode, then we can start talking about efficiency.
Maybe they have something up their sleeve that they haven't shown publicly yet—some kind of filtering XOR masks or something more complex that might work. Anyway, maybe it's just a more elegant way to achieve the same thing, though not necessarily faster than other solutions. I'm waiting when someone finally breaks the last puzzle and this madness will end |
|
|
|
|
Bram24732
Member
Offline
Activity: 322
Merit: 28
|
|
April 05, 2025, 11:29:26 AM
Last edit: April 06, 2025, 11:32:29 AM by hilariousandco |
|
1. I still cannot understand how and why this work...can you elaborate on this please?
2. what do you mean by "At least I know that if you have the correct base key for the right bit flip?
thanks
Python code: xor_masks = {
67: 0b1100111100000011110111001010001111100110101111010011111001010001,
66: 0b10111110011010001001010001011000011010100101000011100101000010001,
65: 0b101011111000111010011101100101011111010010011011001011110011000,
64: 0b100011111010111000001101100001001111011011101110110100101011,
63: 0b1100110001101000010000001001010011001100001001011111110111,
62: 0b100111000010101010111110000101001001111011100101010000010001,
61: 0b110000110110100101011100100010111101000010011011011011111001,
60: 0b111111100001011110011111011010110010011000010001000001,
59: 0b10110110100100110100010001111000001101010100101110110000,
58: 0b100111001100010100100011110101101111001110110010111011110,
57: 0b10100110110100011011011111000011010100010100111100011,
56: 0b1100010111001110100100111000101001110110000000000100000,
55: 0b10101010000011110000001100100100110000001111011101011,
54: 0b11100100100000100100100101010010100101110000010111100,
53: 0b111111110000111011100011011100000011100110110010011,
52: 0b1000001010001111010011011001101000110000111000011,
51: 0b101011111000111101011110010111111111011000101011,
50: 0b1110101000010101111000011110100010110110010101011,
49: 0b100010111110100010010100111111101010000010110010,
48: 0b10100100001100100101000001100011100010001100100,
47: 0b100110010100111101111010010101100001101000101,
46: 0b100010011111001111100011101110010101010111011,
45: 0b11011101000000110101111010111100001111111010,
44: 0b11111110101001100101001011100101001110000,
43: 0b10100001011000100110110000011101001101110,
42: 0b10101110111011110001110100111001001110000,
41: 0b1010110001111001011001010011001110100100,
40: 0b1011001010001101101101100110000101001,
39: 0b11010010100000011111001111110000010110,
38: 0b1110111000111110100000101001100101111,
37: 0b100010101000100010101001010101101100,
36: 0b11000100001011111011111010110000011,
35: 0b1101010001001011011110111010001111,
34: 0b10110101100110100110111011100010,
33: 0b1010110100100110101011100100111,
32: 0b1000111100111010101100111010001,
31: 0b10101100000001100010111000,
30: 0b10011010110011001010011011,
29: 0b1000000111011010101011100001,
28: 0b10011011101001001100010111,
27: 0b1010100111100011110001010,
26: 0b101111111100110110010001,
25: 0b1011010000100011010,
24: 0b1000111101010111111011,
23: 0b1010101001000110101101,
22: 0b100100001101111110000,
21: 0b1000101101011001011,
20: 0b101101001110101010,
19: 0b101000101101100000,
18: 0b1111011111110010,
17: 0b1000100110110000,
16: 0b11011011001001,
15: 0b1011100001100,
14: 0b1011011001111,
13: 0b101110011111,
12: 0b10110000100,
11: 0b1101111100,
10: 0b111111101,
9: 0b101100,
8: 0b11111,
7: 0b110011,
6: 0b1110,
5: 0b1010,
4: 0b111,
3: 0b0,
2: 0b0,
1: 0b0
}
def generate_private_keys():
print("Puzzle | Private Key")
print("-------------------")
for puzzle in range(1, 68):
if puzzle in xor_masks:
puzzle_end = 2**puzzle - 1
private_key = puzzle_end ^ xor_masks[puzzle]
print(f"{puzzle:6} | {private_key}")
else:
print(f"{puzzle:6} | (Missing XOR mask)")
generate_private_keys()Is it clearer now? If not, then nothing. Hi, still no understand why this works...and why it is more efficient than bruteforcing. The masks I suppose are the result of Mutagen? Can you take please two minutes to explain in full? also, "private_key = puzzle_end ^ xor_masks[puzzle]" is useless given that you xor the end of the range which is all 1s with the "mask", so in reality your "mask" is the opposite bits of the private key ALWAYS...meaning it gives you nothing! Thanks It’s not more efficient than brute forcing. It actually requires the exact same number of computations than brute force to scan the range. Yup, even with my skills, it’s obvious that the total number of bit combinations is the same as the keys in the puzzle. So I’ll probably use this approach when choosing the sub-ranges I’m scanning: start from the previous range, apply the mutagen to that string. If the key is found before 50% of the 50% expected in random mode, then we can start talking about efficiency. Nope, it will only mean they were lucky on this particular instance and will have no impact on any future puzzle whatsoever. Yup, even with my skills, it’s obvious that the total number of bit combinations is the same as the keys in the puzzle. So I’ll probably use this approach when choosing the sub-ranges I’m scanning: start from the previous range, apply the mutagen to that string.
If the key is found before 50% of the 50% expected in random mode, then we can start talking about efficiency.
Maybe they have something up their sleeve that they haven't shown publicly yet—some kind of filtering XOR masks or something more complex that might work. Anyway, maybe it's just a more elegant way to achieve the same thing, though not necessarily faster than other solutions. It is not faster, it’s actually way slower. KtimesG already explained why. |
I solved 67 and 68 using custom software distributing the load across ~25k GPUs. 4090 stocks speeds : ~8.1Bkeys/sec. Don’t challenge me technically if you know shit about fuck, I’ll ignore you. Same goes if all you can do is LLM reply.
|
|
|
randrange
Newbie
Offline
Activity: 1
Merit: 0
|
|
April 05, 2025, 01:29:00 PM |
|
Randomly changing 7 bits in 19 bits for a 20-bit private key is more efficient than randomly generating 19 bits. However, it is less certain because it only works if one of the mutations is the target key.
|
|
|
|
|
Bram24732
Member
Offline
Activity: 322
Merit: 28
|
|
April 05, 2025, 02:28:14 PM |
|
Randomly changing 7 bits in 19 bits for a 20-bit private key is more efficient than randomly generating 19 bits. However, it is less certain because it only works if one of the mutations is the target key.
“Doing less work is faster” - no joke. You do a fraction of the work and get a fraction of the odds. Same as when you brute a range. |
I solved 67 and 68 using custom software distributing the load across ~25k GPUs. 4090 stocks speeds : ~8.1Bkeys/sec. Don’t challenge me technically if you know shit about fuck, I’ll ignore you. Same goes if all you can do is LLM reply.
|
|
|
AlanJohnson
Member
Offline
Activity: 185
Merit: 11
|
|
April 05, 2025, 02:31:40 PM |
|
Randomly changing 7 bits in 19 bits for a 20-bit private key is more efficient than randomly generating 19 bits. However, it is less certain because it only works if one of the mutations is the target key.
And if not ? You 'work' is pointless ? And you never know ? |
|
|
|
|
|
kTimesG
|
|
April 05, 2025, 02:42:44 PM |
|
Randomly changing 7 bits in 19 bits for a 20-bit private key is more efficient than randomly generating 19 bits. However, it is less certain because it only works if one of the mutations is the target key.
“Doing less work is faster” - no joke. You do a fraction of the work and get a fraction of the odds. Same as when you brute a range. Be careful... you're on your way to be called a Digaran. A dream crusher. Perhaps influenced by bad ChatGPT answers. No one even cares that you solved 67. It's all about mutating bits nowadays, though it's basically the same thing (if not worse) as picking random keys and hashing them, which is like... the worst plan one can ever have. I think everyone forgot the basics, as stated by the Creator himself: that the puzzles are a crude measurement instrument for the cracking strength of the community. Not a voodoo witch hunt, taking out water from the ocean using a teaspoon. Oh, and the ocean is the size of Jupiter, while the spoon is the size of a bacteria. No one talks about maybe creating a good distributed computing system, which is all that the puzzles are about for some time now. Perhaps because that kind of challenge is not for them at all. |
Off the grid, training pigeons to broadcast signed messages.
|
|
|
AlanJohnson
Member
Offline
Activity: 185
Merit: 11
|
|
April 05, 2025, 03:11:50 PM |
|
Randomly changing 7 bits in 19 bits for a 20-bit private key is more efficient than randomly generating 19 bits. However, it is less certain because it only works if one of the mutations is the target key.
“Doing less work is faster” - no joke. You do a fraction of the work and get a fraction of the odds. Same as when you brute a range. Be careful... you're on your way to be called a Digaran. A dream crusher. Perhaps influenced by bad ChatGPT answers. No one even cares that you solved 67. It's all about mutating bits nowadays, though it's basically the same thing (if not worse) as picking random keys and hashing them, which is like... the worst plan one can ever have. I think everyone forgot the basics, as stated by the Creator himself: that the puzzles are a crude measurement instrument for the cracking strength of the community. Not a voodoo witch hunt, taking out water from the ocean using a teaspoon. Oh, and the ocean is the size of Jupiter, while the spoon is the size of a bacteria. No one talks about maybe creating a good distributed computing system, which is all that the puzzles are about for some time now. Perhaps because that kind of challenge is not for them at all. What the hell is "voodoo witch hunt" ?!  |
|
|
|
|
Akito S. M. Hosana
Jr. Member
Offline
Activity: 420
Merit: 8
|
|
April 05, 2025, 03:37:06 PM |
|
as stated by the Creator himself: that the puzzles are a crude measurement instrument for the cracking strength of the community.
I don't believe anything in his story.  |
|
|
|
|
FrozenThroneGuy
Member
Offline
Activity: 72
Merit: 43
|
|
April 05, 2025, 03:41:51 PM
Last edit: April 06, 2025, 11:31:48 AM by hilariousandco |
|
Hi, guys! What speed is rtx 4060 in KeyhuntCuda (with any modification, may be)? My speed (original version of Keyhunt cuda from GitHub) is 1.3Gkey/s but I think, that it will be faster, than my test speed. Right now I try to do GPU Cyclone and my speed without secp256k1 computing (only compressed public key increment on 1 each iterations, hash160 and comparing to given hash160 (Incrementing pubkey on 1 each iterations not right, but only for tests) is 2.2Gkeys/s and I apologise that this is slow. Wait a minute. If he just said that the 3060 achieves around 2300 Mkeys/s, how much does the 4090 achieve? Does it reach 8000 Mkeys/s on the RTX 4090? 8 GK/s ? In Cyclone GPU ? Why won't anyone share the fastest GPU code here? Are you hiding the best code for yourselves? It's all just empty talk and blah blah blah.. Because no one is obliged to put their work in the public domain for everyone to see. They spend their time and energy on it. Because I am doing it right now:) The main target - to be twice faster than KeyhuntCUDA, but it is possible only with PTX ASM. And also if somebody knows an algo of Modular inverse faster that DRS62 - let me know. this is the main goal for me. Or stupidly do all of the code with PTX, that impossible for me |
|
|
|
|
wizard872
Newbie
Offline
Activity: 5
Merit: 0
|
|
April 05, 2025, 06:22:28 PM |
|
I'm looking for 12 billion keys per second with 2 RTX4090s,
but I don't know when I'll find them.
It's like playing a 0.001% gacha game with electric power
|
|
|
|
|
Bram24732
Member
Offline
Activity: 322
Merit: 28
|
|
April 05, 2025, 06:53:12 PM |
|
I think everyone forgot the basics, as stated by the Creator himself: that the puzzles are a crude measurement instrument for the cracking strength of the community.
Well the measurement does not look good 🤣 |
I solved 67 and 68 using custom software distributing the load across ~25k GPUs. 4090 stocks speeds : ~8.1Bkeys/sec. Don’t challenge me technically if you know shit about fuck, I’ll ignore you. Same goes if all you can do is LLM reply.
|
|
|
|
kTimesG
|
|
April 05, 2025, 07:16:29 PM |
|
Wait a minute. If he just said that the 3060 achieves around 2300 Mkeys/s, how much does the 4090 achieve? Does it reach 8000 Mkeys/s on the RTX 4090? 8 GK/s ? In Cyclone GPU ? Why won't anyone share the fastest GPU code here? Are you hiding the best code for yourselves? It's all just empty talk and blah blah blah.. Because no one is obliged to put their work in the public domain for everyone to see. They spend their time and energy on it. Because I am doing it right now:) The main target - to be twice faster than KeyhuntCUDA, but it is possible only with PTX ASM. And also if somebody knows an algo of Modular inverse faster that DRS62 - let me know. this is the main goal for me. Or stupidly do all of the code with PTX, that impossible for me If you want it to be faster you have to change the high level parameters of perception and adjust for the specific device characteristics. VanitySearch is more like a port from CPU to CUDA rather than a parallel-thought problem. So all clones follow the same philosophy more or less. Micro-optimizations with PTX may end up producing the same final SASS as plain C. You might lose a year to optimize some inverse only to find it works slower than initially on some random new GPU, and faster on another. I have 3 versions (SafeGCD, BinGCD and the one by RC), each of them runs better or worse depending on whether I change a single line of code in a totally different part of the kernel source. So it's more a game of luck to have a perfect faster kernel, depending on whether the compiler decides or not to maybe not spill an extra register just because you swapped two lines that are logically non-dependent |
Off the grid, training pigeons to broadcast signed messages.
|
|
|
|
fixedpaul
|
|
April 05, 2025, 08:27:48 PM |
|
Wait a minute. If he just said that the 3060 achieves around 2300 Mkeys/s, how much does the 4090 achieve? Does it reach 8000 Mkeys/s on the RTX 4090? 8 GK/s ? In Cyclone GPU ? Why won't anyone share the fastest GPU code here? Are you hiding the best code for yourselves? It's all just empty talk and blah blah blah.. Because no one is obliged to put their work in the public domain for everyone to see. They spend their time and energy on it. Because I am doing it right now:) The main target - to be twice faster than KeyhuntCUDA, but it is possible only with PTX ASM. And also if somebody knows an algo of Modular inverse faster that DRS62 - let me know. this is the main goal for me. Or stupidly do all of the code with PTX, that impossible for me When computing modular inverses in batch, the individual function to calculate the inverse has very little impact on the overall speed. In my version, a "stock" 4090 achieves around 7Gkey/s with some optimizations. Still, it's crazy to see how in a group like this, 3/4 of the posts go against all common sense and basic rules of statistics. I'm referring to the absurd theories about prefixes and bit permutations. |
|
|
|
|
FrozenThroneGuy
Member
Offline
Activity: 72
Merit: 43
|
|
April 06, 2025, 04:12:04 AM |
|
Wait a minute. If he just said that the 3060 achieves around 2300 Mkeys/s, how much does the 4090 achieve? Does it reach 8000 Mkeys/s on the RTX 4090? 8 GK/s ? In Cyclone GPU ? Why won't anyone share the fastest GPU code here? Are you hiding the best code for yourselves? It's all just empty talk and blah blah blah.. Because no one is obliged to put their work in the public domain for everyone to see. They spend their time and energy on it. Because I am doing it right now:) The main target - to be twice faster than KeyhuntCUDA, but it is possible only with PTX ASM. And also if somebody knows an algo of Modular inverse faster that DRS62 - let me know. this is the main goal for me. Or stupidly do all of the code with PTX, that impossible for me When computing modular inverses in batch, the individual function to calculate the inverse has very little impact on the overall speed. In my version, a "stock" 4090 achieves around 7Gkey/s with some optimizations. Still, it's crazy to see how in a group like this, 3/4 of the posts go against all common sense and basic rules of statistics. I'm referring to the absurd theories about prefixes and bit permutations. I agree with you, sequential brute force is the best way for solving puzzles without pubkey. And one question, could you take me a link to your version of Keyhunt cuda? KtimesG, I need a few time to understand your opinion:) I checked occupancy of my rtx4060 via nSight Computing, and I have seen “register pressure” on SM (33.3% of occupancy) and spill to DRAM. I will do some work for recalculate algos for decreasing pressure. |
|
|
|
|
|
