Those are figures starting from zero; I think the behaviour is a bit different with (for example) start=1e9 end=1e9+1e8

which I have just run four times, getting

interval=10000: 23287.8 seconds (lots of blocks)
interval=100000: 5348.9 seconds (about 60 blocks)
interval=1000000: 2816 seconds (seven blocks)
interval=10000000: 2162.8 seconds (three blocks)

start=1e11, end=1e11+1e9, interval=1e8 (i.e. very much larger than the ~40 million primes in the range, of which we never look at more than half at once) took 22489 seconds for the first chunk, which was [b]all[/b] the 5-mod-12 primes (whereas interval=1e6 took 13169 seconds for about 10% of the 5-mod-12 primes); quite a lot of RAM (up to 3.3 gigabytes), but I have quite a lot of RAM so that's OK.

start=5e10, end=6e10, interval=4e7 is taking up to 3.6 gigabytes at times and hasn't yet finished an interval; this would suggest that interval=2e8, which would hold all the primes and finish the job in three bites, would take about twenty gigabytes.

[QUOTE=MrRepunit;270749]Not irrelevant, but there is an optimal value of the interval.
Here are my timings:

pmax interval seconds
5000000 2000000 69
5000000 1000000 66
5000000 500000 64
5000000 100000 73
5000000 50000 61
5000000 10000 44
5000000 5000 42
5000000 1000 52

You can see that the optimal interval value is always 1/1000 of the upper boundary.[/QUOTE]

Yes, there is obviously an optimal interval. These are really small tests, the times are very close: [42,73] sec., and this is due to the fast calculation of n! mod T^2.

[QUOTE=fivemack;270756]
start=1e11, end=1e11+1e9, interval=1e8 (i.e. very much larger than the ~40 million primes in the range, of which we never look at more than half at once) took 22489 seconds for the first chunk, which was [b]all[/b] the 5-mod-12 primes (whereas interval=1e6 took 13169 seconds for about 10% of the 5-mod-12 primes); quite a lot of RAM (up to 3.3 gigabytes), but I have quite a lot of RAM so that's OK.[/QUOTE]

The code uses O(log(en)*interval) memory; yes the test uses about ~20 million primes of that range for p==1 mod 3, so the product tree holds only the product of ~20 million primes. But you will see (much) larger product tress in this test also because when when we calulcate the tail of the (p-1)! mod p^2 the "func" calculates the product of approx. "interval"/2 consecutive integers with product tree.

Thanks for your times, those gives that an interval of k*1e7 for these high p values (p>>1e10) uses a little less than k GB of RAM.

Now that we have some coordination: I'll check the range 6e10 to 7e10.

I decided to collect the data (at least temporarily) on [URL="http://users.jyu.fi/~tamaraja/Wilson.html"]this web page[/URL] so as to give an easier reference for the reservations and results. If you come up with more appropriate place (a dedicated and updated thread here? Or another place where other results are also gathered?) I'll remove that page.

I am currently also doing 100G .. 102G (might as well do my calibration runs in useful territory); 100G-101G is currently in the final stage, writing out about an 80M range of residues every eleven minutes with 600M to go. Reserve 102G-110G also.

got one!
 

100660783343 -1+87p

(100G..101G complete, took 79427.6 seconds utime and 3.647G maximum memory, using interval size '1e8' i.e. whole interval at once, on one core of 1.9GHz Magny Cours)

101G-102G complete; 200194.42 seconds on one core of 1.9GHz Magny Cours, using interval 4e6 (11 blocks). Maximum memory usage 0.397GB. No interesting primes found.

[code]
Testing p=101000000051...101405292671, p==11 mod 12, time=131 sec. 35080
Testing p=101000000011...101202702379, p==1 mod 3, time=35211 sec. 10799
Testing p=101000000033...101405467049, p==5 mod 12, time=46010 sec. 19699
Testing p=101202702439...101405417359, p==1 mod 3, time=65679 sec. 12196
Testing p=101405292839...101810835047, p==11 mod 12, time=77875 sec. 40467
Testing p=101405417539...101608187797, p==1 mod 3, time=118342 sec. 11902
Testing p=101405467061...101811138809, p==5 mod 12, time=130244 sec. 18794
Testing p=101608187887...101810900473, p==1 mod 3, time=149038 sec. 11539
Testing p=101810835143...101999999987, p==11 mod 12, time=160577 sec. 25263
Testing p=101810900479...101999999923, p==1 mod 3, time=185840 sec. 11258
Testing p=101811138917...101999999897, p==5 mod 12, time=197098 sec. 12504
Done the st=101000000000-en=102000000000 interval. Time=209602 sec.
200194.42user 1538.25system 58:13:21elapsed 96%CPU
[/code]

[QUOTE=fivemack;270936]101G-102G complete; 200194.42 seconds on one core of 1.9GHz Magny Cours, using interval 4e6 (11 blocks). Maximum memory usage 0.397GB. No interesting primes found.
[/QUOTE]

Thanks, your table also shows the speed ratio is somewhat close to the theoretical ratio: 1:2:3 for different type of primes.
(Don't see the last three blocks, because in those there are less than "interval" primes.)

First (near) hit here:
[INDENT]60373446719 -1-48p[/INDENT]
[SIZE="1"]My new (cheap) computer should arrive soon so I can use more than just my laptop to this and other things...[/SIZE]

I also found a few more:

12896325149 -1+86p
13286279999 -1+52p
21950810731 -1+93p
23607097193 -1+97p
41659815553 -1+55p
42647052491 -1+10p

Still the range is not completed yet...

Reserve 110G..111G for further calibration exercise: how does interval=2e7 behave differently memory-wise from interval=1e8 when both are larger than the total number of primes?

I would like to help out with the search. You guys are taking R. Gerbicz's code and compiling it, but what command line parameters are you using?

I see talk about different ranges are better for things, but if you have core2 based CPUs what would the best settings be? Did I see that someone said it is better to run it on 1 core because running it on multiple ends up being the same speed?