uint32 do_msieve_filtering(fact_obj_t *fobj, msieve_obj *obj, nfs_job_t *job)
{
FILE *tmp, *logfile;
uint32 relations_needed;
uint32 flags = 0;
char nfs_args[80];
flags = flags | MSIEVE_FLAG_USE_LOGFILE;
if (VFLAG > 0)
flags = flags | MSIEVE_FLAG_LOG_TO_STDOUT;
flags = flags | MSIEVE_FLAG_NFS_FILTER;
obj->flags = flags;
if (job->use_max_rels > 0)
{
sprintf(nfs_args, "filter_maxrels=%u", job->use_max_rels);
obj->nfs_args = nfs_args;
if (VFLAG >= 0)
printf("nfs: commencing msieve filtering with reduced relation set\n");
}
else
{
if (VFLAG >= 0)
printf("nfs: commencing msieve filtering\n");
}
logfile = fopen(fobj->flogname, "a");
if (logfile == NULL)
{
printf("fopen error: %s\n", strerror(errno));
printf("could not open yafu logfile for appending\n");
}
else
{
if (job->use_max_rels > 0)
logprint(logfile, "nfs: commencing msieve filtering with reduced relation set\n");
else
logprint(logfile, "nfs: commencing msieve filtering\n");
fclose(logfile);
}
tmp = fopen(fobj->nfs_obj.fbfile,"r");
if (tmp == NULL)
ggnfs_to_msieve(fobj, job);
//else
// fclose(tmp);
else // test if the fb file is for this job
{
char line[GSTR_MAXSIZE];
mpz_t num, r;
mpz_init(num);
mpz_init(r);
while (fgets(line,GSTR_MAXSIZE,tmp))
{
if (line[0] == 'N')
{
mpz_set_str(num, line + 2, 0);
mpz_tdiv_r(r, fobj->nfs_obj.gmp_n, num);
if (mpz_cmp_ui(r, 0) == 0) // match, do nothing
{
fclose(tmp);
break;
}
else
{
if (VFLAG > 0)
printf("nfs: warning: .fb file didn't match current job, overwriting\n");
fclose(tmp);
ggnfs_to_msieve(fobj, job);
break;
}
}
}
mpz_clear(r);
mpz_clear(num);
}
printf("%s\n",obj->input); //mp_print(mpN, 10, NULL, gstr1.s));
relations_needed = nfs_filter_relations(obj, fobj->nfs_obj.gmp_n);
// reset the args list
obj->nfs_args = NULL;
return relations_needed;
}
/*--------------------------------------------------------------------*/
uint32 factor_gnfs(msieve_obj *obj, mp_t *n,
factor_list_t *factor_list) {
int32 status;
uint32 bits;
sieve_param_t params;
mp_poly_t rat_poly;
mp_poly_t alg_poly;
uint32 relations_found = 0;
uint32 max_relations = 0;
uint32 factor_found = 0;
/* Calculate the factor base bound */
bits = mp_bits(n);
get_sieve_params(bits, ¶ms);
logprintf(obj, "commencing number field sieve (%d-digit input)\n",
strlen(mp_sprintf(n, 10, obj->mp_sprintf_buf)));
/* generate or read in the NFS polynomials */
memset(&rat_poly, 0, sizeof(rat_poly));
memset(&alg_poly, 0, sizeof(alg_poly));
status = read_poly(obj, n, &rat_poly, &alg_poly, ¶ms.skewness);
if (status != 0 &&
(obj->flags & (MSIEVE_FLAG_NFS_POLY1 |
MSIEVE_FLAG_NFS_POLY2))) {
status = find_poly(obj, n);
status = read_poly(obj, n, &rat_poly,
&alg_poly, ¶ms.skewness);
}
if (status != 0) {
printf("error generating or reading NFS polynomials\n");
return 0;
}
analyze_one_poly(obj, &rat_poly, &alg_poly, params.skewness);
if ((obj->flags & MSIEVE_FLAG_STOP_SIEVING) ||
!(obj->flags & (MSIEVE_FLAG_NFS_SIEVE |
MSIEVE_FLAG_NFS_FILTER |
MSIEVE_FLAG_NFS_LA |
MSIEVE_FLAG_NFS_SQRT))) {
return 0;
}
/* if we're supposed to be sieving,
initialize the savefile */
if (obj->flags & (MSIEVE_FLAG_NFS_SIEVE |
MSIEVE_FLAG_NFS_FILTER)) {
/* figure out how many relations to look for, and
quit early if that many have already been found */
relations_found = nfs_init_savefile(obj, n);
if (obj->max_relations > 0) {
max_relations = relations_found +
obj->max_relations;
}
else {
/* if no guidance on this is available, make a
wild guess: a fixed fraction of the total number
of large primes possible */
max_relations = 0.8 * (params.rfb_lp_size /
(log((double)params.rfb_lp_size) - 1) +
params.afb_lp_size /
(log((double)params.afb_lp_size) - 1));
}
}
/* this is a little tricky: perform only sieving (and
quit when enough relations are found), only filtering
(and quit if it fails, or continue the postprocessing
if it succeeds), or alternate between sieving and
filtering until the filtering succeeds */
while (1) {
if (!(obj->flags & (MSIEVE_FLAG_NFS_SIEVE |
MSIEVE_FLAG_NFS_FILTER))) {
break;
}
if (obj->flags & MSIEVE_FLAG_NFS_SIEVE) {
savefile_open(&obj->savefile, SAVEFILE_APPEND);
relations_found = do_line_sieving(obj, ¶ms, n,
relations_found,
max_relations);
savefile_close(&obj->savefile);
if (relations_found == 0)
break;
if (!(obj->flags & MSIEVE_FLAG_NFS_FILTER))
return 0;
}
if (obj->flags & MSIEVE_FLAG_STOP_SIEVING)
return 0;
if (obj->flags & MSIEVE_FLAG_NFS_FILTER) {
max_relations = nfs_filter_relations(obj, n);
if (max_relations == 0)
break;
logprintf(obj, "filtering wants %u more relations\n",
max_relations);
if (!(obj->flags & MSIEVE_FLAG_NFS_SIEVE))
return 0;
max_relations += relations_found;
}
}
if (obj->flags & MSIEVE_FLAG_NFS_LA)
nfs_solve_linear_system(obj, n);
if (obj->flags & MSIEVE_FLAG_NFS_SQRT)
factor_found = nfs_find_factors(obj, n, factor_list);
return factor_found;
}
