20040629, 01:27  #1 
Dec 2003
Hopefully Near M48
11011011110_{2} Posts 
Predicting the Amount of CPU Power Needed to LL Test Exponent p
I already know that the amount of CPU power needed to LL test an exponent p is (in the long run) proportional to p^2 * log p.
I also know that there is a sudden increase in the CPU power needed for an LL test whenever the FFT Size increases. However, I still don't know how to predict the amount of CPU power (in say, P90 years) needed for any given exponent, p. I have noted that the Individual Account Report does show the total number of CPU years completed. Therefore, if people could please post the number of CPU years gained when any particular exponent finishes (please post the exponent too), I could try to build a function that predicts the number of CPU years needed for exponent p. Preferably, the function should be accurate in the shortterm (within a given FFT size) and in the longterm (where it would approximate to constant*p^2*log p, but I would like to know the value of the constant). Thanks 
20040629, 02:28  #2 
"Mark"
Feb 2003
Sydney
3×191 Posts 
This chart was made by GP2, I think.

20040629, 03:48  #3 
Dec 2003
Hopefully Near M48
1758_{10} Posts 
That's good, but "reading off" that graph wouldn't be very accurate. Also, I would want this function to apply to exponents below 10M and above 80M.
From what I can see, this function would be given by a series of line segments. Thus, I would need to find the starting coordinates and slope of each segment. Based on the data at http://www.mersenne.org/status.htm, the starting xcoordinate of each segment is best modelled as: x = (6.43063534*10^6)*(1.185101565)^n, where n can be any integer (negative values are needed to extend to smaller exponents). If I assume that each line segment would pass through the origin if extended, then all I need is the starting ycoordinate of each segment to get my function. If I can't find that, I could instead find the coordinates of a different point on the segment. However, more points would likely lead to a better estimate, and maybe I could find a pattern that would allow me to predict the slope of other segments. I've also made a multistep formula to predict the FFT size of exponent p. Again, its based on looking for a pattern at http://www.mersenne.org/status.htm: 1) Divide p by 6.43063534*10^6 2) Take the natural logarithm 3) Divide by 0.1698284798 4) Round down to the next integer. Call this answer x. 5) FFT Size ~= (3.756235034*10^5)*(1.188862372)^x Unfortunately, this estimate is likely to be accurate for only some processors (in particular, NOT P4's). It is stated on the page that: "FFT sizes are for the latest program version not using SSE2 instructions. The Pentium 4 SSE2 code has slightly different ranges for each FFT size. Previous versions of the program also used different ranges for each FFT size." Again, more data is always helpful. Thanks Last fiddled with by jinydu on 20040629 at 04:00 
20040629, 06:41  #4 
"Mark"
Feb 2003
Sydney
3·191 Posts 
I think GP2 made the chart to show CPU credit, from information on the GIMPS status page. I took the low & high points of each range, multiplied by the "PII400 Speed" for the range, then multiplied by the quoted factor of 5.5 to change to P90 units. Converted from seconds to years, they appear to match the line segments of the chart  as well as can be judged!
(I agree about the chart's readability, especially as I do more doublechecks than firsttime tests.) As a second verification, I had a double check 11302037 sent to PrimeNet this morning. My credit went up by 0.733, which is exactly what these calculations gave for that exponent. You make a good point, that to work out the cpu power (time) needed for an exponent, there are other factors such as cpu type. The cpu credit is a "one size fits all" calculation. Last fiddled with by markr on 20040629 at 06:44 
20040629, 09:00  #5 
Aug 2002
Termonfeckin, IE
2^{4}×173 Posts 
jindyu,
Ask robreid at Team_Prime_Rib . If you go to the team stats page at www.teamprimerib.com you will see that we are already calculating what you want for each exponent returned by a member of our team. 
20040629, 09:45  #6  
Dec 2003
Hopefully Near M48
2×3×293 Posts 
Quote:
Also, I assume you mean robcreid. How can I contact him? Thanks Last fiddled with by jinydu on 20040629 at 09:46 

20040629, 12:11  #7 
Dec 2003
Hopefully Near M48
2×3×293 Posts 
M12376097 takes 0.803 P90 years, for the record. I'll start compiling a list.

20040629, 20:18  #8 
Aug 2002
3×5^{2}×7 Posts 
This is what you need!
function calc_p90($exp)
/* calc_90 : calculate P90 value for LL and DC, input is exponent, output is P90 cpu yrs. */ { if ($exp <= 4598000) $exp_p90 = $exp * 0.119; else if ($exp >= 4598001 & $exp <= 5255000) $exp_p90 = $exp * 0.132; else if ($exp >= 5255001 & $exp <= 6520000) $exp_p90 = $exp * 0.173; else if ($exp >= 6520001 & $exp <= 7760000) $exp_p90 = $exp * 0.211; else if ($exp >= 7760001 & $exp <= 9040000) $exp_p90 = $exp * 0.252; else if ($exp >= 9040001 & $exp <= 10330000) $exp_p90 = $exp * 0.281; else if ($exp >= 10330001 & $exp <= 12830000) $exp_p90 = $exp * 0.372; else if ($exp >= 12830001 & $exp <= 15300000) $exp_p90 = $exp * 0.453; else if ($exp >= 15300001 & $exp <= 17850000) $exp_p90 = $exp * 0.536; else if ($exp >= 17850001 & $exp <= 20400000) $exp_p90 = $exp * 0.6; else if ($exp >= 20400001 & $exp <= 25350000) $exp_p90 = $exp * 0.776; else if ($exp >= 25350001 & $exp <= 30150000) $exp_p90 = $exp * 0.934; else if ($exp >= 30150001 & $exp <= 35100000) $exp_p90 = $exp * 1.113; else if ($exp >= 35100001 & $exp <= 40250000) $exp_p90 = $exp * 1.226; else if ($exp >= 40250001 & $exp <= 50000000) $exp_p90 = $exp * 1.64; else if ($exp >= 50000001 & $exp <= 59400000) $exp_p90 = $exp * 1.99; else if ($exp >= 59400001 & $exp <= 69100000) $exp_p90 = $exp * 2.38; else if ($exp >= 69100001 & $exp <= 79300000) $exp_p90 = $exp * 2.604; else $exp_p90 = 0; $exp_p90 = $exp_p90 * 5.5 / 31536000; return $exp_p90; } 
20040629, 23:42  #9 
Aug 2002
New Zealand
31 Posts 
That code looks familiar
I'm sure there is a tidier to code it but it seems to work and match the credit that appears on primenet. If you are wondering where the various numbers come from : The exponent ranges are based on the table on the Mersenne Status page. The multiplier for each range is comes from the PII400 Speed column on the same table. So its : Exponent (same as the number of iterations needed to complete the LL) multiplied byThe number of PII400 seconds to complete an iteration at the fft size of the exponent multiplied by5.5 (to convert to P90 seconds) divided by31536000 (to convert to P90 years) I'm sorry but I can't find the original posts or chats logs where George gave us this info but I think I remember it correctly. Last fiddled with by robreid on 20040629 at 23:44 
20040630, 09:53  #10  
Aug 2002
20D_{16} Posts 
Quote:


20041130, 13:52  #11 
May 2004
Oslo, Norway
78_{16} Posts 
I recently started a thread over the same matter in the "new to GIMPS" section, as I was unaware of this one. However, I was lead to this thread, and I'm very grateful for robreid's code example. I have reworked the code into a fully working Python script, and at the same time simplified it to  hopefully  make it a little more lucid.
My latest version is here: Code:
#! /usr/bin/env python # leifbk 2004, based on work by robcreid of Team Prime Rib def calc_p90(exp): """ Purpose: Match the GIMPS P90 LL credits as closely as possible. Input is Mersenne exponent (long integer), output is P90 CPU years (float). For an explanation, see http://www.mersenneforum.org/showthread.php?t=2731. The numbers are from http://www.mersenne.org/status.htm. The coefficients are the numbers given in the 'PII400 Speed' column, multiplied by the cited factor of 5.5 to convert to P90 CPU time.""" secs = 0.0 # secs : number of P90 seconds if exp < 4598000 : secs = exp * 0.6545 if exp > 4598000 : secs = exp * 0.726 if exp > 5255000 : secs = exp * 0.9515 if exp > 6520000 : secs = exp * 1.1605 if exp > 7760000 : secs = exp * 1.386 if exp > 9040000 : secs = exp * 1.5455 if exp > 10330000 : secs = exp * 2.046 if exp > 12830000 : secs = exp * 2.4915 if exp > 15300000 : secs = exp * 2.948 if exp > 17850000 : secs = exp * 3.3 if exp > 20400000 : secs = exp * 4.268 if exp > 25350000 : secs = exp * 5.137 if exp > 30150000 : secs = exp * 6.1215 if exp > 35100000 : secs = exp * 6.743 if exp > 40250000 : secs = exp * 9.02 if exp > 50000000 : secs = exp * 10.945 if exp > 59400000 : secs = exp * 13.09 if exp > 69100000 : secs = exp * 14.322 return secs / 31536000 # convert to years if __name__ == '__main__': from sys import argv print '%3.3f' % calc_p90(int(argv[1])) regards, Leif. 
Thread Tools  
Similar Threads  
Thread  Thread Starter  Forum  Replies  Last Post 
Is more sieving power needed?  jasong  jasong  4  20120325 19:11 
Result Not Needed Error on assigned exponent  Christenson  PrimeNet  2  20110527 05:24 
Predicting the needed time for high nvalues?  Rincewind  Sierpinski/Riesel Base 5  4  20090611 12:24 
Stability Test for Cool'n'Quiet and PowerSupply  Mark.S  Hardware  5  20040512 10:16 
amount of memory needed for Stage 2 (factor)  pin  Software  13  20030318 19:54 