Commit f1ce13c7 authored by Emmanuel Thomé's avatar Emmanuel Thomé
Browse files

some renames

parent efb4ea74
This repository contains information to reproduce the RSA-240, DLP-240 and RSA-250 records.
* [RSA240](rsa240/README.md)
* [DLP240](dlp240/README.md)
* [RSA250](rsa250/README.md)
* [RSA-240](rsa240/README.md)
* [DLP-240](dlp240/README.md)
* [RSA-250](rsa250/README.md)
# RSA240
# RSA-240
This repository contains information to reproduce the RSA-240 factoring record.
......@@ -257,7 +257,7 @@ side 1.)
$CADO_BUILD/sieve/ecm/precompbatch -poly rsa240.poly -lim0 0 -lim1 2100000000 -batch0 $DATA/rsa240.batch0 -batch1 $DATA/rsa240.batch1 -batchlpb0 31 -batchlpb1 30
```
Then, we can use the [`sieve-batch.sh`](sieve-batch.sh) shell-script
Then, we can use the [`rsa240-sieve-batch.sh`](rsa240-sieve-batch.sh) shell-script
given in this repository. This launches:
- one instance of las, that does the sieving on side 1 and print the
survivors to files;
......@@ -279,7 +279,7 @@ When the paths are properly set (either by having `CADO_BUILD` and
`DATA` set correctly, or by tweaking the script), a typical invocation
is as follows:
```
./sieve-batch.sh -q0 2100000000 -q1 2100100000
./rsa240-sieve-batch.sh -q0 2100000000 -q1 2100100000
```
The script prints on stdout the start and end date, and in the output of
`las` that can be found in `$DATA/log/las.${q0}-${q1}.out`, the number
......@@ -288,16 +288,16 @@ again deduce the cost in core.seconds to process one special-q and then
the overall cost of sieving the q-range [2.1e9,7.4e9].
The design of this script imposes to have a rather long range of
special-q to handle for each run of sieve-batch.sh . Indeed, during the
special-q to handle for each run of `rsa240-sieve-batch.sh`. Indeed, during the
last minutes, the finishbatch jobs need to take care of the last survivor
files while las is no longer running, so that the node is not fully
occupied. If the `sieve-batch.sh` job takes a few hours, this fade-out
occupied. If the `rsa240-sieve-batch.sh` job takes a few hours, this fade-out
phase takes negligible time. Both for the benchmark and in production it
is then necessary to have jobs taking at least a few hours.
On our sample machine, here is an example of a benchmark:
```
./sieve-batch.sh -q0 2100000000 -q1 2100100000 > /tmp/sieve-batch.out
./rsa240-sieve-batch.sh -q0 2100000000 -q1 2100100000 > /tmp/sieve-batch.out
[ wait ... ]
......@@ -385,18 +385,18 @@ small work units that in the end cover exactly the global q-range.
Since we do not expect anyone to spend again as much computing resources
to perform again exactly the same computation, we provide in the
[`rel_count`](rel_count) file the count of how many (non-unique) relations were
produced for each 100M special-q sub-range.
[`rsa240-rel_count`](rsa240-rel_count) file the count of how many
(non-unique) relations were produced for each 100M special-q sub-range.
We can then have a visual plot of this data, as shown in
[`plot_rel_count.pdf`](plot_rel_count.pdf) where we see the drop in the number of relations
produced per special-q when changing the strategy
(the x-coordinate is the special-q value, divided by 100M).
The plot is very
regular on the two sub-ranges, except for outliers corresponding to the
q-range [9e8,1e9]. This is due to a crash of a computing facilities, and
it was easier to allow duplicate computations (hence duplicate relations)
than to sort out exactly which special-q's did not complete.
[`rsa240-plot_rel_count.pdf`](rsa240-plot_rel_count.pdf) where we see the
drop in the number of relations produced per special-q when changing the
strategy (the x-coordinate is the special-q value, divided by 100M). The
plot is very regular on the two sub-ranges, except for outliers
corresponding to the q-range [9e8,1e9]. This is due to a crash of a
computing facilities, and it was easier to allow duplicate computations
(hence duplicate relations) than to sort out exactly which special-q's
did not complete.
In order to validate our computation, it is possible to re-compute only
one of the sub-ranges (except 9e8-1e9) and check that the number of
......
# Additional info on filtering for rsa240
# Additional info on filtering for RSA-240
A first step of the filtering process in cado-nfs is to create the
so-called "renumber table", as follows.
......@@ -88,10 +88,10 @@ Total usage: time 379175s (cpu), 36492s (wct) ; memory 3675M, peak 1314500M
The merge step used revision `8e651c0a6` of cado-nfs, which implements the
algorithm described in the article
Charles Bouillaguet and Paul Zimmermann, _Parallel Structured Gaussian Elimination for the Number Field Sieve_, April 2019, [`https://hal.inria.fr/hal-02098114`](https://hal.inria.fr/hal-02098114)
Charles Bouillaguet and Paul Zimmermann, _Parallel Structured Gaussian Elimination for the Number Field Sieve_, April 2019, [`https://hal.inria.fr/hal-02098114`](https://hal.inria.fr/hal-02098114)
```
$CADO_BUILD/filter/merge -out history$EXP -t 56 -target_density 200 -mat purged$EXP.gz -skip 32
$CADO_BUILD/filter/merge -out $DATA/history$EXP -t 56 -target_density 200 -mat $DATA/purged$EXP.gz -skip 32
```
An excerpt of the output is:
......@@ -130,10 +130,10 @@ Total usage: time 131669s (cpu), 8926s (wct) ; memory 536456M, peak 795576M
## The "replay" step
The replay step used revision 1369194a5 of cado-nfs.
The replay step used revision `1369194a5` of cado-nfs.
```
$CADO_BUILD/replay -purged purged$EXP.gz -his history$EXP -out rsa240.matrix$EXP.200.bin -index rsa240.index$EXP.gz
$CADO_BUILD/replay -purged $DATA/purged$EXP.gz -his $DATA/history$EXP -out $DATA/rsa240.matrix$EXP.200.bin -index $DATA/rsa240.index$EXP.gz
```
An excerpt of the output is:
......@@ -153,4 +153,3 @@ Sparse submatrix: nrows=282336644 ncols=282336484
Total usage: time 32650s (cpu), 32502s (wct) ; memory 802686M, peak 915127M
```
#
# Additional info on polynomial selection for RSA-240
This file contains reproducibility information for the polynomial selection
step of the factorization of RSA-240.
We used revision 52ac92746 of CADO-NFS.
We used revision `52ac92746` of cado-nfs.
The first stage of polynomial selection (size optimization) was equivalent to
the following:
the following pseudo-code
```
for admin from 0 to 2000000000000 by 2500000:
admax = admin + 2500000
polyselect -P 20000000 -N 124620366781718784065835044608106590434820374651678805754818788883289666801188210855036039570272508747509864768438458621054865537970253930571891217684318286362846948405301614416430468066875699415246993185704183030512549594371372159029236099 -degree 6 -t 1 -admin $admin -admax $admax -incr 110880 -nq 1296 -sopteffort 20
```
We found 39890071 size-optimized polynomials, we kept the 104 most-promising
ones (i.e., the ones with the smallest "exp_E" value). The best exp_E was
57.78, the worst exp_E was 59.49.
We found 39890071 size-optimized polynomials, we kept the 104 most promising
ones (i.e., the ones with the smallest `exp_E` value). The best `exp_E` was
57.78, the worst `exp_E` was 59.49.
We used the following command-line for root optimization (still with CADO-NFS
revision 52ac92746), where "candidates" is the file containing all candidates
We used the following command line for root optimization (still with cado-nfs
revision `52ac92746`), where `candidates` is the file containing all candidates
kept after size optimization:
polyselect_ropt -inputpolys candidates -Bf 2.1e9 -Bg 1.8e9 -area 2.4e19 -ropteffort 10 -t 104
```
$CADO_BUILD/polyselect/polyselect_ropt -inputpolys candidates -Bf 2.1e9 -Bg 1.8e9 -area 2.4e19 -ropteffort 10 -t 104
```
The polynomial used for the factorization was the best polynomial output at the
end of the polyselect_ropt run (the one with the largest MurphyE value, namely
7.41e-13).
The polynomial used for the factorization was the best polynomial output
at the end of the `polyselect_ropt` run (the one with the largest MurphyE
value, namely 7.41e-13).
We also did a sieving test for all 104 root-optimized polynomials, using the
following command (where $1 is the corresponding root-optimized file):
following command (where `$1` is the corresponding root-optimized file):
sieve/makefb -poly $1 -lim 2100000000 -maxbits 17 -out /tmp/$1.roots -t 64
sieve/las -poly $1 -fb1 /tmp/$1.roots -lim0 1800000000 -lim1 2100000000 -lpb0 36 -lpb1 37 -q0 1e8 -q1 3e9 -dup -dup-qmin 0,100000000 -sqside 1 -A 33 -mfb0 72 -mfb1 111 -lambda0 2.0 -lambda1 3.0 -random-sample 128 -t auto -bkmult 1,1l:1.15,1s:1.4,2s:1.1 -v -bkthresh1 80000000
```
$CADO_BUILD/sieve/makefb -poly $1 -lim 2100000000 -maxbits 17 -out /tmp/`basename $1`.roots -t 64
$CADO_BUILD/sieve/las -poly $1 -fb1 /tmp/`basename $1`.roots -lim0 1800000000 -lim1 2100000000 -lpb0 36 -lpb1 37 -q0 1e8 -q1 3e9 -dup -dup-qmin 0,100000000 -sqside 1 -A 33 -mfb0 72 -mfb1 111 -lambda0 2.0 -lambda1 3.0 -random-sample 128 -t auto -bkmult 1,1l:1.15,1s:1.4,2s:1.1 -v -bkthresh1 80000000
```
The polynomial with the largest average number of relations per special-q
was the one with the largest MurphyE value, with an average of 48.6 relations
per special-q.
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment