P90 CPU Years and PrimeNet

[S485122]

I tried to compute the number of CPU years awarded for an exponent. I tried a lot of computations, using the Benchmark http://mersenne.org/bench.htm for instance.
Then before posting I read some previous posts about the subject. I found an algorithm:
if Exponent <= 4598000 then PII400_Iteration_time = 0.119 else
if Exponent <= 5255000 then PII400_Iteration_time = 0.132 else
if Exponent <= 6520000 then PII400_Iteration_time = 0.173 else
if Exponent <= 7760000 then PII400_Iteration_time = 0.211 else
if Exponent <= 9040000 then PII400_Iteration_time = 0.252 else
if Exponent <= 10330000 then PII400_Iteration_time = 0.281 else
if Exponent <= 12830000 then PII400_Iteration_time = 0.372 else
if Exponent <= 15300000 then PII400_Iteration_time = 0.453 else
if Exponent <= 17850000 then PII400_Iteration_time = 0.536 else
if Exponent <= 20400000 then PII400_Iteration_time = 0.6 else
if Exponent <= 25350000 then PII400_Iteration_time = 0.776 else
if Exponent <= 30150000 then PII400_Iteration_time = 0.934 else
if Exponent <= 35100000 then PII400_Iteration_time = 1.113 else
if Exponent <= 40250000 then PII400_Iteration_time = 1.226 else
if Exponent <= 50000000 then PII400_Iteration_time = 1.64 else
if Exponent <= 59400000 then PII400_Iteration_time = 1.99 else
if Exponent <= 69100000 then PII400_Iteration_time = 2.38 else
if Exponent <= 79300000 then PII400_Iteration_time = 2.604 else
PII400_Iteration_time = 0
P90_CPU_Years = PII400_Iteration_time * 5.5 * Exponent / 31536000"
But this does not seem to be correct. I tried to adapt the values by using the current values given by the benchmark tool. Still the values computed do not correspond to the values awarded by PrimeNet.
Could somebody give me the current table used by PrimeNet?
And would it not be simpler to just put all computing time in flops (or FlOp/s) (Megaflops, Gigaflops, whatever ...). This would cause a problem, the moment the GIMPS search will use a program using integer computation of course, but then the P90 CPU Years would give the same translation problem. For the moment it would be much more transparent...

[axn]

This is the correct logic. What is the exponent, your estimation and Primenet's credit, so that we could debug it?

As for having a simpler method, this method is fairly strightforward (IMHO). Maybe it can't be expressed as a formula, but it is very simple to calculate

[cheesehead]

From http://www.mersenne.org/primenet/status.shtml, the P90 calibration is 32.98 megaflop/s.

365.25 days is 31557600 seconds.

One P90 CPU-year is, therefore, about 1.0407 * 10¹⁵ flop, only 4% more than a petaflop.

[S485122]

Sorry I goofed up writting one exponent down. The algorithm does indeed give the exact credit.

My suggestion to change the unit is not affected by this : the algorithm gives a PII 400 iteration time of 0.372s for an exponent between 10330001 and 12830000 while the Benchmark page gives a 0.468s for the same exponent. There are differences for every exponent range between the algorithm and the benchmark page, the FFT bounds are different as well.

Indeed the unit Pflop would not change much in actual figures and could be computed indepentantly from the benchmark of a particular processor. Another advantage is that the number of floating point operations can be computed by using the theory (number of iterations, FFT size.)

[S485122]

I searched some more on the forum and found a thread that discussed V5 of primenet. It seems that there are plans for a change in measuring units :

Originally Posted by Old man PrimeNet

Two years ago this design document initially captured the v5 system concept and objectives, though it's now woefully outdated and lacks details for feature-level implementation. However, the v5 GIMPS client web API specification is current for the system in development and describes data-level dependencies that hint at how the system works and what will be available for users on the web site.

The design document proposes the following unit :

"CPU Time for Assignment Results - GIMPS CPU time is reckoned in units of GHz-Hours where 1 floating point operation (FLOP) is expected to require 1 CPU clock cycle, FLOP ~ Hz. For Lucas-Lehmer tests, the number of FLOPs required to determine primality is deterministically known for a given exponent, p (E.W. Mayer):
For Lucas-Lehmer Series using DWT:
FLOP(p) = 5/16 . p2 . [log2(p) - 4]
teraflop(p) = FLOP(p) / 1 000 000 000 000
To compute the CPU performance in FLOP/sec simply divide FLOP(p) by the assignment test time in seconds. For example, M(40) p = 20996011, so teraflop(20996011) = 2799.78 trillion FLOPs (2.8 exaflops). Computing M(40) required about 19 days with a day or so weekend downtime, so 2799.78 trillion FLOPs / 19 days = 0.0017 trillion FLOPs / second, or 1.7 billion FLOPs / sec, reflecting a 19-day average CPU clock rate of 1.7 GHz - quite close to the actual 2 GHz of the CPU.
Given for GIMPS that FLOP ~ Hz, it is then straightforward to compute the GHz-hours for the assignment by:
GHz-Hours(p) = teraflop(p) / 3.6 = FLOP(p) / 3 600 000 000 000
Other benchmark extrapolation methods are used for factoring and other kinds of work_type."

If implement some day this answers my question.

[jinydu]

Originally Posted by Jacob Visser

I searched some more on the forum and found a thread that discussed V5 of primenet. It seems that there are plans for a change in measuring units :



The design document proposes the following unit :

"CPU Time for Assignment Results - GIMPS CPU time is reckoned in units of GHz-Hours where 1 floating point operation (FLOP) is expected to require 1 CPU clock cycle, FLOP ~ Hz. For Lucas-Lehmer tests, the number of FLOPs required to determine primality is deterministically known for a given exponent, p (E.W. Mayer):
For Lucas-Lehmer Series using DWT:
FLOP(p) = 5/16 . p2 . [log2(p) - 4]
teraflop(p) = FLOP(p) / 1 000 000 000 000
To compute the CPU performance in FLOP/sec simply divide FLOP(p) by the assignment test time in seconds. For example, M(40) p = 20996011, so teraflop(20996011) = 2799.78 trillion FLOPs (2.8 exaflops). Computing M(40) required about 19 days with a day or so weekend downtime, so 2799.78 trillion FLOPs / 19 days = 0.0017 trillion FLOPs / second, or 1.7 billion FLOPs / sec, reflecting a 19-day average CPU clock rate of 1.7 GHz - quite close to the actual 2 GHz of the CPU.
Given for GIMPS that FLOP ~ Hz, it is then straightforward to compute the GHz-hours for the assignment by:
GHz-Hours(p) = teraflop(p) / 3.6 = FLOP(p) / 3 600 000 000 000
Other benchmark extrapolation methods are used for factoring and other kinds of work_type."

If implement some day this answers my question.

In that example, the error in the estimate is about 17.6%; and if I'm not mistaken, the current way in which credit is assigned gives an estimate accurate to within a few percent. Thus, that new method would be less accurate, which is a bad thing...

[S485122]

jinydu how did you compute this 17.6% error ? How do you compute the real cpu time in PII400 multiplied by 5.5 equivalents ?

As I said the benchmark page uses different values from the primenet server for the same exponent and the differences can be more than 25%.

I would prefer a unit in Exaflop than a unit going back to GHz. A flop is something independant of a CPU. If for instance a CPU has a more than one floting point unit or even integer processing unit, the whole GHz system does not work anymore since one cycle could be equivalent to more than one flop... Of course even with flops you can have flops and flops (32 bit flops, 512 bit flops). This means that the best unit would be the sum of operation times their respective weight (something like "operationbits" or obs ;-)

[cheesehead]

Originally Posted by Jacob Visser

A flop is something independant of a CPU.

... but ...

Of course even with flops you can have flops and flops (32 bit flops, 512 bit flops)

I withdraw my suggestion to replace P-90 CPU-years by petaflops.

Sometimes the old ways are the best. I've not yet seen any convincing argument that the P-90-CPU-year is inferior to any other measure of GIMPS achievement.

[jinydu]

Originally Posted by Jacob Visser

jinydu how did you compute this 17.6% error ? How do you compute the real cpu time in PII400 multiplied by 5.5 equivalents ?

.

Originally Posted by Jacob Visser

reflecting a 19-day average CPU clock rate of 1.7 GHz - quite close to the actual 2 GHz of the CPU.

[S485122]

To compute the CPU performance in FLOP/sec simply divide FLOP(p) by the assignment test time in seconds. For example, M(40) p = 20996011, so teraflop(20996011) = 2799.78 trillion FLOPs (2.8 exaflops). Computing M(40) required about 19 days with a day or so weekend downtime, so 2799.78 trillion FLOPs / 19 days = 0.0017 trillion FLOPs / second, or 1.7 billion FLOPs / sec, reflecting a 19-day average CPU clock rate of 1.7 GHz - quite close to the actual 2 GHz of the CPU.

jinydu, I think that you overlooked the part about downtime : "Computing M(40) required about 19 days with a day or so weekend downtime". This means that the whole calculation is not a benchmark of the accuracy of the calculation.