[CODE]p=55204091[@76 bits/B1=B2=405000] B1=410000, B2=7175000, prob= 1.31
p=55098229[@75 bits/B1=B2=460000] B1=420000, B2=7980000, prob= 1.45
p=55197041[@75 bits/B1=B2=460000] B1=420000, B2=7980000, prob= 1.45
p=55835839[@75 bits/B1=B2=470000] B1=440000, B2=8250000, prob= 1.48
p=45571601[@72 bits/B1=B2=510000] B1=390000, B2=8677500, prob= 1.82
p=46130221[@72 bits/B1=B2=515000] B1=390000, B2=8775000, prob= 1.83
p=46207093[@72 bits/B1=B2=520000] B1=390000, B2=8775000, prob= 1.82
p=47324509[@72 bits/B1=B2=525000] B1=405000, B2=8910000, prob= 1.85
p=54258847[@74 bits/B1=B2=525000] B1=420000, B2=8715000, prob= 1.56
p=54476567[@74 bits/B1=B2=525000] B1=420000, B2=8715000, prob= 1.56
p=54476573[@74 bits/B1=B2=525000] B1=420000, B2=8715000, prob= 1.56
p=54476593[@74 bits/B1=B2=525000] B1=420000, B2=8715000, prob= 1.56
p=54476663[@74 bits/B1=B2=525000] B1=420000, B2=8715000, prob= 1.56
p=54476833[@74 bits/B1=B2=525000] B1=420000, B2=8715000, prob= 1.56
p=54476861[@74 bits/B1=B2=525000] B1=420000, B2=8715000, prob= 1.56
p=54680371[@74 bits/B1=B2=525000] B1=430000, B2=8815000, prob= 1.58
p=54698719[@74 bits/B1=B2=525000] B1=430000, B2=8815000, prob= 1.58
p=54698759[@74 bits/B1=B2=525000] B1=430000, B2=8815000, prob= 1.58
p=54847097[@74 bits/B1=B2=525000] B1=440000, B2=8910000, prob= 1.60
p=55072681[@74 bits/B1=B2=530000] B1=440000, B2=8910000, prob= 1.59
p=48091517[@72 bits/B1=B2=555000] B1=400000, B2=9000000, prob= 1.81
p=48099379[@72 bits/B1=B2=555000] B1=405000, B2=9011250, prob= 1.82
p=49232621[@72 bits/B1=B2=560000] B1=420000, B2=9450000, prob= 1.87
p=49235027[@72 bits/B1=B2=560000] B1=420000, B2=9450000, prob= 1.87
p=49304473[@72 bits/B1=B2=560000] B1=420000, B2=9450000, prob= 1.87
p=45018373[@72 bits/B1=B2=565000] B1=340000, B2=7990000, prob= 1.62
p=45434309[@71 bits/B1=B2=570000] B1=400000, B2=9700000, prob= 2.02
p=46218209[@72 bits/B1=B2=575000] B1=365000, B2=8668750, prob= 1.71
p=46262267[@72 bits/B1=B2=575000] B1=370000, B2=8695000, prob= 1.72
p=46665911[@72 bits/B1=B2=580000] B1=370000, B2=8695000, prob= 1.71
p=46780159[@71 bits/B1=B2=580000] B1=430000, B2=10105000, prob= 2.08
p=54440039[@73 bits/B1=B2=580000] B1=450000, B2=9900000, prob= 1.77
p=54440083[@73 bits/B1=B2=580000] B1=450000, B2=9900000, prob= 1.77
p=54440291[@73 bits/B1=B2=580000] B1=450000, B2=9900000, prob= 1.77
p=54440369[@73 bits/B1=B2=580000] B1=450000, B2=9900000, prob= 1.77
p=54440389[@73 bits/B1=B2=580000] B1=450000, B2=9900000, prob= 1.77
p=54442631[@73 bits/B1=B2=580000] B1=450000, B2=9900000, prob= 1.77
p=54442643[@73 bits/B1=B2=580000] B1=450000, B2=9900000, prob= 1.77
p=54444287[@73 bits/B1=B2=580000] B1=450000, B2=9900000, prob= 1.77
p=54444323[@73 bits/B1=B2=580000] B1=450000, B2=9900000, prob= 1.77
p=54444373[@73 bits/B1=B2=580000] B1=450000, B2=9900000, prob= 1.77
p=54475163[@73 bits/B1=B2=580000] B1=450000, B2=9900000, prob= 1.77
p=54627889[@73 bits/B1=B2=580000] B1=455000, B2=9896250, prob= 1.77
p=54628121[@73 bits/B1=B2=580000] B1=455000, B2=9896250, prob= 1.77
p=54629101[@73 bits/B1=B2=580000] B1=455000, B2=9896250, prob= 1.77
p=50249491[@72 bits/B1=B2=585000] B1=430000, B2=9675000, prob= 1.88
p=50377819[@72 bits/B1=B2=585000] B1=430000, B2=9675000, prob= 1.88
p=54758579[@73 bits/B1=B2=585000] B1=450000, B2=9900000, prob= 1.76
p=50575991[@72 bits/B1=B2=590000] B1=430000, B2=9782500, prob= 1.88
p=54846683[@73 bits/B1=B2=595000] B1=450000, B2=9900000, prob= 1.75
[/CODE]
These are the numbers I get, assuming these are first time LLs. Caveat Emptor.

EDIT:- Ooh... I forgot a rather giant caveat. This is best-case calculation assuming you've allocated enough memory for 485 temporary. For these exponents, that means somewhere around 12GB!!

[QUOTE=Dubslow;285746]?

Let me rephrase my last sentence:

Losing factors and doing more LL is directly contrary to GIMPS' goal. Therefore, if we had sufficient P-1 resources (which we don't) then Stage 1 only would be a fairly decent detriment. If P-1 ever gets ahead of the wavefront, then we should go back and redo some of these.[/QUOTE]

I agree with this.

I was only saying that since we are not, only doing P-1 Stage 1 helps the project.

[QUOTE=axn;285738]Are all of these first time LLs?[/QUOTE]

Yes. They were all (at one time or another) assigned to Spidy by PrimeNet as true LL tests.

[QUOTE=axn;285747][CODE]p=55204091[@76 bits/B1=B2=405000] B1=410000, B2=7175000, prob= 1.31
p=55098229[@75 bits/B1=B2=460000] B1=420000, B2=7980000, prob= 1.45
p=55197041[@75 bits/B1=B2=460000] B1=420000, B2=7980000, prob= 1.45
p=55835839[@75 bits/B1=B2=470000] B1=440000, B2=8250000, prob= 1.48
p=45571601[@72 bits/B1=B2=510000] B1=390000, B2=8677500, prob= 1.82
p=46130221[@72 bits/B1=B2=515000] B1=390000, B2=8775000, prob= 1.83
p=46207093[@72 bits/B1=B2=520000] B1=390000, B2=8775000, prob= 1.82
p=47324509[@72 bits/B1=B2=525000] B1=405000, B2=8910000, prob= 1.85
p=54258847[@74 bits/B1=B2=525000] B1=420000, B2=8715000, prob= 1.56
p=54476567[@74 bits/B1=B2=525000] B1=420000, B2=8715000, prob= 1.56
p=54476573[@74 bits/B1=B2=525000] B1=420000, B2=8715000, prob= 1.56
p=54476593[@74 bits/B1=B2=525000] B1=420000, B2=8715000, prob= 1.56
p=54476663[@74 bits/B1=B2=525000] B1=420000, B2=8715000, prob= 1.56
p=54476833[@74 bits/B1=B2=525000] B1=420000, B2=8715000, prob= 1.56
p=54476861[@74 bits/B1=B2=525000] B1=420000, B2=8715000, prob= 1.56
p=54680371[@74 bits/B1=B2=525000] B1=430000, B2=8815000, prob= 1.58
p=54698719[@74 bits/B1=B2=525000] B1=430000, B2=8815000, prob= 1.58
p=54698759[@74 bits/B1=B2=525000] B1=430000, B2=8815000, prob= 1.58
p=54847097[@74 bits/B1=B2=525000] B1=440000, B2=8910000, prob= 1.60
p=55072681[@74 bits/B1=B2=530000] B1=440000, B2=8910000, prob= 1.59
p=48091517[@72 bits/B1=B2=555000] B1=400000, B2=9000000, prob= 1.81
p=48099379[@72 bits/B1=B2=555000] B1=405000, B2=9011250, prob= 1.82
p=49232621[@72 bits/B1=B2=560000] B1=420000, B2=9450000, prob= 1.87
p=49235027[@72 bits/B1=B2=560000] B1=420000, B2=9450000, prob= 1.87
p=49304473[@72 bits/B1=B2=560000] B1=420000, B2=9450000, prob= 1.87
p=45018373[@72 bits/B1=B2=565000] B1=340000, B2=7990000, prob= 1.62
p=45434309[@71 bits/B1=B2=570000] B1=400000, B2=9700000, prob= 2.02
p=46218209[@72 bits/B1=B2=575000] B1=365000, B2=8668750, prob= 1.71
p=46262267[@72 bits/B1=B2=575000] B1=370000, B2=8695000, prob= 1.72
p=46665911[@72 bits/B1=B2=580000] B1=370000, B2=8695000, prob= 1.71
p=46780159[@71 bits/B1=B2=580000] B1=430000, B2=10105000, prob= 2.08
p=54440039[@73 bits/B1=B2=580000] B1=450000, B2=9900000, prob= 1.77
p=54440083[@73 bits/B1=B2=580000] B1=450000, B2=9900000, prob= 1.77
p=54440291[@73 bits/B1=B2=580000] B1=450000, B2=9900000, prob= 1.77
p=54440369[@73 bits/B1=B2=580000] B1=450000, B2=9900000, prob= 1.77
p=54440389[@73 bits/B1=B2=580000] B1=450000, B2=9900000, prob= 1.77
p=54442631[@73 bits/B1=B2=580000] B1=450000, B2=9900000, prob= 1.77
p=54442643[@73 bits/B1=B2=580000] B1=450000, B2=9900000, prob= 1.77
p=54444287[@73 bits/B1=B2=580000] B1=450000, B2=9900000, prob= 1.77
p=54444323[@73 bits/B1=B2=580000] B1=450000, B2=9900000, prob= 1.77
p=54444373[@73 bits/B1=B2=580000] B1=450000, B2=9900000, prob= 1.77
p=54475163[@73 bits/B1=B2=580000] B1=450000, B2=9900000, prob= 1.77
p=54627889[@73 bits/B1=B2=580000] B1=455000, B2=9896250, prob= 1.77
p=54628121[@73 bits/B1=B2=580000] B1=455000, B2=9896250, prob= 1.77
p=54629101[@73 bits/B1=B2=580000] B1=455000, B2=9896250, prob= 1.77
p=50249491[@72 bits/B1=B2=585000] B1=430000, B2=9675000, prob= 1.88
p=50377819[@72 bits/B1=B2=585000] B1=430000, B2=9675000, prob= 1.88
p=54758579[@73 bits/B1=B2=585000] B1=450000, B2=9900000, prob= 1.76
p=50575991[@72 bits/B1=B2=590000] B1=430000, B2=9782500, prob= 1.88
p=54846683[@73 bits/B1=B2=595000] B1=450000, B2=9900000, prob= 1.75
[/CODE]
These are the numbers I get, assuming these are first time LLs. Caveat Emptor.[/QUOTE]
Yikes. Those probabilities are lower than expected. Take the second to last exponent -- James' site reports that it's 2.50 GD work, at 180+GD to test it. So 180*.0188=3.38 GD, so that does seem to turn a profit for GIMPS.

[QUOTE=Dubslow;285752]Yikes. Those probabilities are lower than expected. Take the second to last exponent -- James' site reports that it's 2.50 GD work, at 180+GD to test it. So 180*.0188=3.38 GD, so that does seem to turn a profit for GIMPS.[/QUOTE]

They're all guaranteed to be profitable, otherwise the computation would spit out B1=0, B2=0, meaning don't do P-1.

[QUOTE=axn;285679]You're assuming that which you want to prove. The whole idea is that upping the default value to 300MB is [B]not[/B] going to cause "noticeable resource drains". The case has been made why 8MB is overly conservative _in today's environment_. To counter that, you've to demonstrate that a significant fraction (say 3%) of the userbase will be affected. Keep in mind that we can only change the default when users install / upgrade to a yet-to-be-released new version of the software -- which users of older machines aren't going to use anyway.[/QUOTE]
axn, I'm not "assuming" anything -- I am speaking from first-hand experience.

Regarding statistics as to the percentage of machines that can or can't do something -- well, [URL="http://www.mersenneforum.org/showthread.php?t=16420"]I've been asking[/URL] if statistics of this kind are publicly available, and thus far nobody has indicated so. (I'd still be happy to be pointed to the data.) So as far as I can tell there is no basis, one way or the other, for making claims as to how many or what proportion of users may or may not be affected by changes.

Now as far as increasing users' P-1 memory allocation: We were asked to provide [URL="http://v5www.mersenne.org/update/"]an e-mail address[/URL] when first registering on PrimeNet. How about sending out a circular briefly describing the situation and the hoped-for improvement, and then asking users to consider upping their allocations if they haven't already done so. This should not be difficult to do, and it could have a bigger and more immediate impact on P-1 than changing the default value on a future Prime95 release.

Rodrigo

[QUOTE=Rodrigo;285769]axn, I'm not "assuming" anything -- I am speaking from first-hand experience.

Regarding statistics as to the percentage of machines that can or can't do something -- well, [URL="http://www.mersenneforum.org/showthread.php?t=16420"]I've been asking[/URL] if statistics of this kind are publicly available, and thus far nobody has indicated so. (I'd still be happy to be pointed to the data.) So as far as I can tell there is no basis, one way or the other, for making claims as to how many or what proportion of users may or may not be affected by changes.
Rodrigo[/QUOTE]

As for that thread, I'll post a bit more specifics there in a second.
[QUOTE=Rodrigo;285769]

Now as far as increasing users' P-1 memory allocation: We were asked to provide [URL="http://v5www.mersenne.org/update/"]an e-mail address[/URL] when first registering on PrimeNet. How about sending out a circular briefly describing the situation and the hoped-for improvement, and then asking users to consider upping their allocations if they haven't already done so. This should not be difficult to do, and it could have a bigger and more immediate impact on P-1 than changing the default value on a future Prime95 release.

Rodrigo[/QUOTE]Interesting idea, but that runs right on the "Beggar's can't be choosers" line, in that nobody has ever gotten that email, nobody is expecting that email, and there's an option to sign up for the Mersenne Newsletter. That last bit means: people we need to reach won't sign up for that, which means that might be angry that they got an email even though they didn't sign up. You might risk losing more than 1 participant if we (George) send out an email.

What I don't get about this default setting is how unhelpful it is.

Putting my newbie hat here.

When I install something, I expect that the program will choose default that will permit it to run properly or within certain parameter.

If I get a dialog box, I will choose the default (I wouldn't want to make mistake!).

You know how people install software?

Join GIMPS!->OK->OK->

[CODE]
---------------------------
Prime95
---------------------------
You have left the available memory fields at 8 megabytes. You can increase
your chances of finding a Mersenne prime very slightly if you let the program
occasionally use more memory. The readme.txt file has more information.
Do you want to let the program use more memory?
---------------------------
Yes No
---------------------------
[/CODE]

Yes->(God damn back to that screen! I said it could use more memory, yet it keep the same setting! Next time I will choose NO!)OK->(Look at that it's not asking me anymore)OK. Done!

No one reads anything, or they deffer the reading for later and never get to it.

Now to the unhelpful part.

1) Why choose 8MB? it's worse than 0MB, at least with 0MB I have a hint that something is wrong. but with 8MB it looks like a good value from the user standpoint, but little does he know that it is far from the required amount for ANY P-1!

2) I just choose yes to the question: Do you want to let the program use more memory? Let's please fill the default with a bare minimum that will let the program work! Lets not leave it at the ALWAYS unhelpful value of 8MB.

3) Then the question refers to the readme.txt file:
[CODE]
Exponent Minimum Reasonable Desirable
-------- ------- ---------- ---------
20000000 40MB 80MB 120MB
33000000 65MB 125MB 185MB
50000000 85MB 170MB 250MB
[/CODE]

NONE of these will permit me to get P-1 work! According to the [URL="http://www.mersenne.org/thresholds/"]threshold page[/URL].

Why not put a chart in the dialog box with the following:

For (insert current wavefront exponent)
0MB - P-1 Unavailable
497MB - P-1 Minimum
12,096MB - P-1 Maximum
59,282MB - P-1 Insane

Note: MB values taken from [URL="http://mersenne-aries.sili.net/prob.php?exponent=55000000&b1=0&b2=0&factorbits=&K=1&C=-1&submitbutton=Calculate"]here[/URL]

That chart is for general (meaning LL/TF) use, not P-1 Stage 2 use.

[QUOTE=Dubslow;285782]That 8MB refers to memory besides that necessary for LL and TF and whatever else work. That chart (I think) refers to LL memory necessary, which is not limited to the 8MB number.[/QUOTE]

NO read the readme!

[CODE]
SETTING P-1/ECM STAGE 2 MEMORY
------------------------------

Stage 2 of P-1 factoring step prior to running a Lucas-Lehmer test is
slightly more effective if it is given more memory to work with. However,
if you let the program use too much memory then the performance of ALL
programs will suffer. The good news is that 98% of the time the program
uses a minimal amount of memory. In fact, the program will work just fine
if you never let it use more than the minimum.

So how do you intelligently choose the memory settings? Below
are some steps you might take to figure this out:

1) Be conservative. It is better to set the memory too low
than too high. Setting the value too high can cause thrashing which
slows down all programs. Remember, the program will only use the
extra memory in stage 2 of P-1 factoring (about 12 hours a month).

2) Start with how much memory is installed in your machine. Allow a
reasonable amount of memory for the OS and whatever background tasks
you run (say 100 or 200MB). This represents the maximum value you should
use. The program won't let you enter more than 90% of installed memory.

3) Assuming you run your machine 24 hours a day, what hours of the
day do you not use your computer? Make these your nighttime hours and
let the program use a lot of memory during these hours. But reduce this
value if you also run batch jobs at night.

4) Factor in the information below about minimum, reasonable, and
desirable memory amounts for some sample exponents. If you choose a
value below the minimum, that is OK. The program will simply skip
stage 2 of P-1 factoring.

Exponent Minimum Reasonable Desirable
-------- ------- ---------- ---------
20000000 40MB 80MB 120MB
33000000 65MB 125MB 185MB
50000000 85MB 170MB 250MB
[/CODE]

My copy has a different title:

[code]SETTING AVAILABLE MEMORY
------------------------

The P-1 factoring step prior to running a Lucas-Lehmer test is more
effective if it is given more memory to work with. However, if you let
the program use too much memory then the performance of ALL programs will
suffer. The good news is that 98% of the time the program uses less
than 8MB. In fact, the program will work just fine if you instruct the
program to use only 8MB or less.

So how do you intelligently choose the available memory settings? Below
are some steps you might take to figure this out:

1) Be conservative. It is better to set the available memory too low
than too high. Setting the value too high can cause thrashing which
slows down all programs. Remember, the program will only use the
extra memory in stage 2 of P-1 factoring (about 12 hours a month).

2) Start with how much memory is installed in your machine. Allow a
reasonable amount of memory for the OS and whatever background tasks
you run (say 100 or 200MB). This represents the maximum value you should use.
The program won't let you enter more than 90% of installed memory.

3) Assuming you run your machine 24 hours a day, what hours of the
day do you not use your computer? Make these your nighttime hours and
let the program use a lot of memory during these hours. But reduce this
value if you also run batch jobs at night.

4) Factor in the information below about minimum, reasonable, and
desirable memory amounts for some sample exponents.

Exponent Minimum Reasonable Desirable
-------- ------- ---------- ---------
20000000 40MB 80MB 120MB
33000000 65MB 125MB 185MB
50000000 85MB 170MB 250MB

For example, my machine is a dual-processor with 512MB of memory.
I guess Linux can survive on 100MB of memory. Thus, I set the available
memory to (512 - 100) or ~400MB. This is my nighttime setting.
During the day, I set the available memory to 80MB. I can always stop
mprime if it is doing P-1 factoring and I detect memory thrashing. More
casual users will probably want to set the daytime memory to 8MB so they
don't have to worry about mprime impacting system performance.

If at all in doubt, leave the settings at 8MB. The worst that will
happen is you end up running a Lucas-Lehmer primality test when stage 2
of P-1 factoring would have found a factor.
[/code]
Though, on further thought, an LL test certainly does not need that much memory (around 50x what's necessary) and yet that is nowhere near enough for P-1 (which needs 10-50x more than that). Now I am suddenly confused.