Predicting the Amount of CPU Power Needed to LL Test Exponent p

[jinydu]

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 short-term (within a given FFT size) and in the long-term (where it would approximate to constant*p^2*log p, but I would like to know the value of the constant).

Thanks

[markr]

This chart was made by GP2, I think.

[jinydu]

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 x-coordinate 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 y-coordinate 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 multi-step 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

[markr]

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 "PII-400 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 double-checks than first-time 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.

[garo]

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.

[jinydu]

Originally Posted by garo

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.

I'm afraid I can't find the calculations. Below is a picture of the left-hand side menu (sorry its distorted, the forum only lets me upload small pictures).

Also, I assume you mean robcreid. How can I contact him?

Thanks

[jinydu]

M12376097 takes 0.803 P90 years, for the record. I'll start compiling a list.

[Joe O]

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;
}

[robreid]

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 PII-400 Speed column on the same table.

So its :-
Exponent (same as the number of iterations needed to complete the LL)

multiplied by

The number of PII-400 seconds to complete an iteration at the fft size of the exponent

multiplied by

5.5 (to convert to P90 seconds)

divided by

31536000 (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.

[Joe O]

Originally Posted by robreid

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.

It should, since you sent it to me. I was too rushed yesterday to give credit where it is due, and I apologize for that. I've been using this code for a while, and it does indeed match the credit on primenet.

[leifbk]

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:

#! /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 'PII-400 Speed' column, multiplied by the cited 
    factor of 5.5 to convert to P-90 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]))

I'd appreciate any comments, and especially if anyone find discrepancies between the values reported by this program and the P90 credits from the GIMPS reports.

regards, Leif.