| Author |
Message |
|---|
|
|
|
Is there a CUDA program for sieving a wide range of Proth numbers?
k*2^N+1 where 10,000<k<10,000,000 and N>10,000
Or even a CPU program?
NewPGen isn't very useful for a wide range of both N and k simultaneously.
At this point, any CUDA program for sieving Proth numbers would be appreciated.
I'm looking to do some independent testing of various ranges. |
|
|
|
|
|
You should be able to use tpsieve-cuda to accomplish what you want. I am not sure how it performs on large k ranges, but I do know that you are able to set the upper and lower k limits at runtime. You can find the executables on the Prime Search Team forums.
____________
 |
|
|
|
|
|
tpsieve-cuda is for twin prime searches.
I tried the ppsieve-cuda, and it wouldn't run, claiming I was missing some type of driver file.
LLR and PFGW are great programs for testing primality, but there don't seem to be any great sieving programs out there. NewPGen has the best GUI, but it's relatively slow, and its author no longer develops it. |
|
|
 Crun-chi Volunteer tester
Send message
Joined: 25 Nov 09
Posts: 3235
ID: 50683
Credit: 151,728,006
RAC: 5,541
                         
|
|
Sr1sieve and sr2sieve are programs you looking for. Both are faster then NewPgen, but NewPgen can do some type of sieve that sr1ieve and sr2sieve cannot do. But since you dont need those types... look for sr1sieve and sr2sieve ( I use it , there is no gui but it has light syntax to run.
They exist for 64 bit OS ( Linux and Win), and there is chance that AVX is used in sieving process , ( speed up about 25%), but there is no exe with AVX support now.
____________
92*10^1585996-1 NEAR-REPDIGIT PRIME :) :) :)
4 * 650^498101-1 CRUS PRIME
2022202116^131072+1 GENERALIZED FERMAT
Proud member of team Aggie The Pew. Go Aggie! |
|
|
Ken_g6Volunteer developer
Send message
Joined: 4 Jul 06
Posts: 940
ID: 3110
Credit: 262,463,562
RAC: 15,728
                    
|
I tried the ppsieve-cuda, and it wouldn't run, claiming I was missing some type of driver file.
What was the message exactly? ppsieve-cuda is probably the best program for what you want.
____________
|
|
|
|
|
|
The title of the pop-up window is "ppsieve-cuda-x86-windows.exe - Unable To Locate Component".
The message:
"This application has failed to start because cudart.dll was not found. Re-installing the application may fix this problem." |
|
|
|
|
|
I downloaded a cudart.dll and placed it in the same directory as the PPSieve-CUDA.exe file.
In command prompt, I am able to run it. Apparently, I now need to figure out how to create a valid input file for the program to operate on!
Does anyone know how to create such a file? |
|
|
|
|
|
OK. I've nearly got this program running, but does it require a large range of both N and k? I tried an input file with a large range of K on N=65000, and it says nmax is close to nmin as an error.
It says: "Error: pmin is not large enough (or nmax is close to nmin)."
The pmin is 1T, so I'm not sure why that would be the problem...
I also tried creating a file from scratch using
-k100001
-K999999
-n65000
-N65010
I used a pmin of 3, but then it demanded that pmin be greater than the k values.
Are you supposed to use some other program to weed out the very small factors? |
|
|
|
|
|
I was able to run the program using k=10001, with 1000<n<1500000
I started the p value at 1T, and it found one factor after about a minute.
The program doesn't remove that particular n value from the input file! It just lists the factors in a separate file. What good is that?! If I find hundreds or thousands of factors, how is the user supposed to remove those numbers before LLR testing?
The GUI and ease of use of these factoring programs could certainly use some improvement. |
|
|
|
|
The program doesn't remove that particular n value from the input file! It just lists the factors in a separate file. What good is that?! If I find hundreds or thousands of factors, how is the user supposed to remove those numbers before LLR testing?
The programs are intended to be used by multiple end-users to sieve, while only one user is maintaining the master list of candidates. I believe that is the reason why composite numbers found during factoring are not removed from the input file. Also if memory serves me correctly, ppsieve-cuda is a datless sieve (meaning there is no input file to begin with).
You should be able to write another script that can keep track of which candidates have been eliminated using the sieve, which candidates you have tested, and which candidates you still need to test. I imagine it would be easiest to store all of these data in some sort of relational database like MySQL.
____________
|
|
|
|
|
|
You can use an input file for ppsieve-cuda.
In general, it seems to give this error rather easily:
"Error: pmin is not large enough (or nmax is close to nmin)."
I'm not clear as to what pmin is supposed to be or how nmax and nmin are to relate to one another. The README file doesn't go into much detail.
I suppose I could write a C++ program that subtracts the composites from the original input file after ppsieve is finished running. It wouldn't be difficult.
Still, I'm confused as to why the developers of these programs don't make them easier to use. NewPGen has a simple, yet nice GUI. |
|
|
Ken_g6Volunteer developer
Send message
Joined: 4 Jul 06
Posts: 940
ID: 3110
Credit: 262,463,562
RAC: 15,728
|
You can use an input file for ppsieve-cuda.
In general, it seems to give this error rather easily:
"Error: pmin is not large enough (or nmax is close to nmin)."
I'm not clear as to what pmin is supposed to be or how nmax and nmin are to relate to one another. The README file doesn't go into much detail.
pmin is the -p value. nmin is -n, and nmax is -N. In the above case, -N was close to -n. Though I don't remember right now why that matters.
I suppose I could write a C++ program that subtracts the composites from the original input file after ppsieve is finished running. It wouldn't be difficult.
I think there is one someplace. Not written by me.
Still, I'm confused as to why the developers of these programs don't make them easier to use. NewPGen has a simple, yet nice GUI.
First, this was made to work with BOINC more than to be used manually. Second, the math that makes this fast has a lot of corner cases where it doesn't work. The error messages are there so you don't hit the corner cases. And, third, I'm not good at GUIs. The only languages I've made GUIs in are Visual Basic 3.0, Java, and HTML. Note the complete lack of any C language here.
____________
|
|
|
|
|
|
The program works for p=1T and P=10T, but when I try to use smaller p values, it fails. What exactly were these "corner" cases?
ppsieve-cuda-x86-windows.exe -p100G -P1T -iinput.txt -r10 -z normal
ppsieve version cuda-0.2.3b (testing)
Found K's from 10001 to 10001.
Found N's from 1071 to 1499960.
nstart=1071, nstep=24
Read 58400 terms from NewPGen format input file `input.txt'
Error: pmin is not large enough (or nmax is close to nmin). |
|
|
|
|
|
Based on trial and error, the lowest value I can give pmin is 336G.
335G outputs that error message.
It would take a long time for NewPGen to sieve up to 336G. |
|
|
JimBHonorary cruncher
Send message
Joined: 4 Aug 11
Posts: 920
ID: 107307
Credit: 989,270,184
RAC: 7,595
                
|
I suppose I could write a C++ program that subtracts the composites from the original input file after ppsieve is finished running. It wouldn't be difficult.
No need to write one, use the srfile program. You can find the program in srsieve-0.6.17-bin.zip on this page.
|
|
|
Ken_g6Volunteer developer
Send message
Joined: 4 Jul 06
Posts: 940
ID: 3110
Credit: 262,463,562
RAC: 15,728
|
The program works for p=1T and P=10T, but when I try to use smaller p values, it fails. What exactly were these "corner" cases?
ppsieve-cuda-x86-windows.exe -p100G -P1T -iinput.txt -r10 -z normal
ppsieve version cuda-0.2.3b (testing)
Found K's from 10001 to 10001.
Found N's from 1071 to 1499960.
nstart=1071, nstep=24
Read 58400 terms from NewPGen format input file `input.txt'
Error: pmin is not large enough (or nmax is close to nmin).
That's going to be an extremely inefficient range. (Or maybe the input file isn't arranged as I expected it, so most of the K's weren't found?) There is currently no efficient GPU sieve for a single K, although Rogue and I were making progress toward one at one point.
Alas, I don't remember all of the corner cases. It's been a couple of years since I actively worked on this.
@JimB, thanks, that's probably the program I was thinking of.
Edit: If you want to split up your range, split it up by N's. But you don't want to go too low, or the system will be CPU-limited.
____________
|
|
|
|
|
|
So the program is built for a wide range of k values all sharing one N value? |
|
|
Ken_g6Volunteer developer
Send message
Joined: 4 Jul 06
Posts: 940
ID: 3110
Credit: 262,463,562
RAC: 15,728
|
So the program is built for a wide range of k values all sharing one N value?
That's how it started. Then I found that, when the highest k value is smaller than the current prime being tested against, it is possible to show that that prime will factor at most one K in a few adjacent N's. So the program skips a few N's at a time by multiplying. For CUDA, I was able to make some exceedingly fast code to multiply by 2^32 (or was it 2^-32). Anyway, CUDA won't jump more than 32 N's at a time because the code is faster that way.
You probably won't get to that fast 32N code, though. The amount that can be jumped is log2(P/Kmax). Your large Kmax will slow things down a little.
By the way, I should mention that the CPU version of ppsieve handles more "corner cases", so if you need to fill in the gap from wherever you are to wherever the CUDA code starts working, try that.
____________
|
|
|
