int main(int argc, char** argv) {
BOINC_OPTIONS boinc_options;
BOINC_STATUS boinc_status;
char buf[256];
int retval;
memset(&boinc_options, 0, sizeof(boinc_options));
boinc_options.main_program = true;
boinc_options.check_heartbeat = true;
boinc_options.handle_process_control = true;
boinc_init_options(&boinc_options);
fprintf(
stderr,
"%s vboxwrapper: starting\n",
boinc_msg_prefix(buf, sizeof(buf))
);
retval = parse_job_file();
if (retval) {
fprintf(
stderr,
"%s can't parse job file: %d\n",
boinc_msg_prefix(buf, sizeof(buf)),
retval
);
boinc_finish(retval);
}
retval = vm.run();
if (retval) {
boinc_finish(retval);
}
while (1) {
vm.poll();
boinc_get_status(&boinc_status);
if (boinc_status.no_heartbeat || boinc_status.quit_request) {
vm.stop();
boinc_temporary_exit(0);
}
if (boinc_status.abort_request) {
vm.cleanup();
boinc_finish(EXIT_ABORTED_BY_CLIENT);
}
if (!vm.is_running()) {
vm.cleanup();
boinc_finish(0);
}
if (boinc_status.suspended) {
if (!vm.suspended) {
vm.pause();
}
} else {
if (vm.suspended) {
vm.resume();
}
}
boinc_sleep(POLL_PERIOD);
}
return 0;
}
//----------------------- NFS ENTRY POINT ------------------------------------//
void nfs(fact_obj_t *fobj)
{
//expect the input in fobj->nfs_obj.gmp_n
char *input;
msieve_obj *obj = NULL;
char *nfs_args = NULL; // unused as yet
enum cpu_type cpu = yafu_get_cpu_type();
mp_t mpN;
factor_list_t factor_list;
uint32 flags = 0;
nfs_job_t job;
uint32 relations_needed = 1;
uint32 last_specialq = 0;
struct timeval stop; // stop time of this job
struct timeval start; // start time of this job
struct timeval bstop; // stop time of sieving batch
struct timeval bstart; // start time of sieving batch
TIME_DIFF * difference;
double t_time;
uint32 pre_batch_rels = 0;
char tmpstr[GSTR_MAXSIZE];
int process_done;
enum nfs_state_e nfs_state;
// initialize some job parameters
memset(&job, 0, sizeof(nfs_job_t));
obj_ptr = NULL;
//below a certain amount, revert to SIQS
if (gmp_base10(fobj->nfs_obj.gmp_n) < fobj->nfs_obj.min_digits)
{
mpz_set(fobj->qs_obj.gmp_n, fobj->nfs_obj.gmp_n);
SIQS(fobj);
mpz_set(fobj->nfs_obj.gmp_n, fobj->qs_obj.gmp_n);
return;
}
if (mpz_probab_prime_p(fobj->nfs_obj.gmp_n, NUM_WITNESSES))
{
add_to_factor_list(fobj, fobj->nfs_obj.gmp_n);
if (VFLAG >= 0)
gmp_printf("PRP%d = %Zd\n", gmp_base10(fobj->nfs_obj.gmp_n),
fobj->nfs_obj.gmp_n);
logprint_oc(fobj->flogname, "a", "PRP%d = %s\n",
gmp_base10(fobj->nfs_obj.gmp_n),
mpz_conv2str(&gstr1.s, 10, fobj->nfs_obj.gmp_n));
mpz_set_ui(fobj->nfs_obj.gmp_n, 1);
return;
}
if (mpz_perfect_square_p(fobj->nfs_obj.gmp_n))
{
mpz_sqrt(fobj->nfs_obj.gmp_n, fobj->nfs_obj.gmp_n);
add_to_factor_list(fobj, fobj->nfs_obj.gmp_n);
logprint_oc(fobj->flogname, "a", "prp%d = %s\n",
gmp_base10(fobj->nfs_obj.gmp_n),
mpz_conv2str(&gstr1.s, 10, fobj->nfs_obj.gmp_n));
add_to_factor_list(fobj, fobj->nfs_obj.gmp_n);
logprint_oc(fobj->flogname, "a", "prp%d = %s\n",
gmp_base10(fobj->nfs_obj.gmp_n),
mpz_conv2str(&gstr1.s, 10, fobj->nfs_obj.gmp_n));
mpz_set_ui(fobj->nfs_obj.gmp_n, 1);
return;
}
if (mpz_perfect_power_p(fobj->nfs_obj.gmp_n))
{
FILE *flog;
uint32 j;
if (VFLAG > 0)
printf("input is a perfect power\n");
factor_perfect_power(fobj, fobj->nfs_obj.gmp_n);
flog = fopen(fobj->flogname, "a");
if (flog == NULL)
{
printf("fopen error: %s\n", strerror(errno));
printf("could not open %s for appending\n", fobj->flogname);
exit(1);
}
logprint(flog,"input is a perfect power\n");
for (j=0; j<fobj->num_factors; j++)
{
uint32 k;
for (k=0; k<fobj->fobj_factors[j].count; k++)
{
logprint(flog,"prp%d = %s\n",gmp_base10(fobj->fobj_factors[j].factor),
mpz_conv2str(&gstr1.s, 10, fobj->fobj_factors[j].factor));
}
}
fclose(flog);
return;
}
if (fobj->nfs_obj.filearg[0] != '\0')
{
if (VFLAG > 0) printf("test: starting trial sieving\n");
trial_sieve(fobj);
return;
}
//initialize the flag to watch for interrupts, and set the
//pointer to the function to call if we see a user interrupt
NFS_ABORT = 0;
signal(SIGINT,nfsexit);
//start a counter for the whole job
gettimeofday(&start, NULL);
//nfs state machine:
input = (char *)malloc(GSTR_MAXSIZE * sizeof(char));
nfs_state = NFS_STATE_INIT;
process_done = 0;
while (!process_done)
{
switch (nfs_state)
{
case NFS_STATE_INIT:
// write the input bigint as a string
input = mpz_conv2str(&input, 10, fobj->nfs_obj.gmp_n);
// create an msieve_obj
// this will initialize the savefile to the outputfile name provided
obj = msieve_obj_new(input, flags, fobj->nfs_obj.outputfile, fobj->nfs_obj.logfile,
fobj->nfs_obj.fbfile, g_rand.low, g_rand.hi, (uint32)0, cpu,
(uint32)L1CACHE, (uint32)L2CACHE, (uint32)THREADS, (uint32)0, nfs_args);
fobj->nfs_obj.mobj = obj;
// initialize these before checking existing files. If poly
// select is resumed they will be changed by check_existing_files.
job.last_leading_coeff = 0;
job.poly_time = 0;
job.use_max_rels = 0;
job.snfs = NULL;
// determine what to do next based on the state of various files.
// this will set job.current_rels if it finds any
nfs_state = check_existing_files(fobj, &last_specialq, &job);
// before we get started, check to make sure we can find ggnfs sievers
// if we are going to be doing sieving
if (check_for_sievers(fobj, 1) == 1)
nfs_state = NFS_STATE_DONE;
if (VFLAG >= 0 && nfs_state != NFS_STATE_DONE)
gmp_printf("nfs: commencing nfs on c%d: %Zd\n",
gmp_base10(fobj->nfs_obj.gmp_n), fobj->nfs_obj.gmp_n);
if (nfs_state != NFS_STATE_DONE)
logprint_oc(fobj->flogname, "a", "nfs: commencing nfs on c%d: %s\n",
gmp_base10(fobj->nfs_obj.gmp_n),
mpz_conv2str(&gstr1.s, 10, fobj->nfs_obj.gmp_n));
// convert input to msieve bigint notation and initialize a list of factors
gmp2mp_t(fobj->nfs_obj.gmp_n,&mpN);
factor_list_init(&factor_list);
if (fobj->nfs_obj.rangeq > 0)
job.qrange = ceil((double)fobj->nfs_obj.rangeq / (double)THREADS);
break;
case NFS_STATE_POLY:
if ((fobj->nfs_obj.nfs_phases == NFS_DEFAULT_PHASES) ||
(fobj->nfs_obj.nfs_phases & NFS_PHASE_POLY))
{
// always check snfs forms (it is fast)
snfs_choose_poly(fobj, &job);
if( job.snfs == NULL )
{
// either we never were doing snfs, or snfs form detect failed.
// if the latter then bail with an error because the user
// explicitly wants to run snfs...
if (fobj->nfs_obj.snfs)
{
printf("nfs: failed to find snfs polynomial!\n");
exit(-1);
}
// init job.poly for gnfs
job.poly = (mpz_polys_t*)malloc(sizeof(mpz_polys_t));
if (job.poly == NULL)
{
printf("nfs: couldn't allocate memory!\n");
exit(-1);
}
mpz_polys_init(job.poly);
job.poly->rat.degree = 1; // maybe way off in the future this isn't true
// assume gnfs for now
job.poly->side = ALGEBRAIC_SPQ;
do_msieve_polyselect(fobj, obj, &job, &mpN, &factor_list);
}
else
{
fobj->nfs_obj.snfs = 1;
mpz_set(fobj->nfs_obj.gmp_n, job.snfs->n);
}
}
nfs_state = NFS_STATE_SIEVE;
break;
case NFS_STATE_SIEVE:
pre_batch_rels = job.current_rels;
gettimeofday(&bstart, NULL);
// sieve if the user has requested to (or by default). else,
// set the done sieving flag. this will prevent some infinite loops,
// for instance if we only want to post-process, but filtering
// doesn't produce a matrix. if we don't want to sieve in that case,
// then we're done.
if (((fobj->nfs_obj.nfs_phases == NFS_DEFAULT_PHASES) ||
(fobj->nfs_obj.nfs_phases & NFS_PHASE_SIEVE)) &&
!(fobj->nfs_obj.nfs_phases & NFS_DONE_SIEVING))
do_sieving(fobj, &job);
else
fobj->nfs_obj.nfs_phases |= NFS_DONE_SIEVING;
// if this has been previously marked, then go ahead and exit.
if (fobj->nfs_obj.nfs_phases & NFS_DONE_SIEVING)
process_done = 1;
// if user specified -ns with a fixed start and range,
// then mark that we're done sieving.
if (fobj->nfs_obj.rangeq > 0)
{
// we're done sieving the requested range, but there may be
// more phases to check, so don't exit yet
fobj->nfs_obj.nfs_phases |= NFS_DONE_SIEVING;
}
// then move on to the next phase
nfs_state = NFS_STATE_FILTCHECK;
break;
case NFS_STATE_FILTER:
// if we've flagged not to do filtering, then assume we have
// enough relations and move on to linear algebra
if ((fobj->nfs_obj.nfs_phases == NFS_DEFAULT_PHASES) ||
(fobj->nfs_obj.nfs_phases & NFS_PHASE_FILTER))
relations_needed = do_msieve_filtering(fobj, obj, &job);
else
relations_needed = 0;
if (relations_needed == 0)
nfs_state = NFS_STATE_LINALG;
else
{
// if we filtered, but didn't produce a matrix, raise the target
// min rels by a few percent. this will prevent too frequent
// filtering attempts while allowing the q_batch size to remain small.
if (job.current_rels > job.min_rels)
job.min_rels = job.current_rels * fobj->nfs_obj.filter_min_rels_nudge;
else
job.min_rels *= fobj->nfs_obj.filter_min_rels_nudge;
if (VFLAG > 0)
printf("nfs: raising min_rels by %1.2f percent to %u\n",
100*(fobj->nfs_obj.filter_min_rels_nudge-1), job.min_rels);
nfs_state = NFS_STATE_SIEVE;
}
break;
case NFS_STATE_LINALG:
if ((fobj->nfs_obj.nfs_phases == NFS_DEFAULT_PHASES) ||
(fobj->nfs_obj.nfs_phases & NFS_PHASE_LA) ||
(fobj->nfs_obj.nfs_phases & NFS_PHASE_LA_RESUME))
{
// msieve: build matrix
flags = 0;
flags = flags | MSIEVE_FLAG_USE_LOGFILE;
if (VFLAG > 0)
flags = flags | MSIEVE_FLAG_LOG_TO_STDOUT;
flags = flags | MSIEVE_FLAG_NFS_LA;
// add restart flag if requested
if (fobj->nfs_obj.nfs_phases & NFS_PHASE_LA_RESUME)
flags |= MSIEVE_FLAG_NFS_LA_RESTART;
obj->flags = flags;
if (VFLAG >= 0)
printf("nfs: commencing msieve linear algebra\n");
logprint_oc(fobj->flogname, "a", "nfs: commencing msieve linear algebra\n");
// use a different number of threads for the LA, if requested
if (LATHREADS > 0)
{
msieve_obj_free(obj);
obj = msieve_obj_new(input, flags, fobj->nfs_obj.outputfile, fobj->nfs_obj.logfile,
fobj->nfs_obj.fbfile, g_rand.low, g_rand.hi, (uint32)0, cpu,
(uint32)L1CACHE, (uint32)L2CACHE, (uint32)LATHREADS, (uint32)0, nfs_args);
}
// try this hack - store a pointer to the msieve obj so that
// we can change a flag on abort in order to interrupt the LA.
obj_ptr = obj;
nfs_solve_linear_system(obj, fobj->nfs_obj.gmp_n);
if (obj_ptr->flags & MSIEVE_FLAG_STOP_SIEVING)
nfs_state = NFS_STATE_DONE;
else
{
// check for a .dat.deps file. if we don't have one, assume
// its because the job was way oversieved and only trivial
// dependencies were found. try again from filtering with
// 20% less relations.
FILE *t;
sprintf(tmpstr, "%s.dep", fobj->nfs_obj.outputfile);
if ((t = fopen(tmpstr, "r")) == NULL)
{
if (job.use_max_rels > 0)
{
// we've already tried again with an attempted fix to the trivial
// dependencies problem, so either that wasn't the problem or
// it didn't work. either way, give up.
printf("nfs: no dependency file retry failed\n");
fobj->flags |= FACTOR_INTERRUPT;
nfs_state = NFS_STATE_DONE;
}
else
{
// this should be sufficient to produce a matrix, but not too much
// to trigger the assumed failure mode.
if (job.min_rels == 0)
{
// if min_rels is not set, then we need to parse the .job file to compute it.
parse_job_file(fobj, &job);
nfs_set_min_rels(&job);
}
job.use_max_rels = job.min_rels * 1.5;
printf("nfs: no dependency file found - trying again with %u relations\n",
job.use_max_rels);
nfs_state = NFS_STATE_FILTER;
}
}
else
{
fclose(t);
nfs_state = NFS_STATE_SQRT;
}
}
// set the msieve threads back to where it was if we used
// a different amount for linalg
if (LATHREADS > 0)
{
msieve_obj_free(obj);
obj = msieve_obj_new(input, flags, fobj->nfs_obj.outputfile, fobj->nfs_obj.logfile,
fobj->nfs_obj.fbfile, g_rand.low, g_rand.hi, (uint32)0, cpu,
(uint32)L1CACHE, (uint32)L2CACHE, (uint32)THREADS, (uint32)0, nfs_args);
}
obj_ptr = NULL;
}
else // not doing linalg
nfs_state = NFS_STATE_SQRT;
break;
case NFS_STATE_SQRT:
if ((fobj->nfs_obj.nfs_phases == NFS_DEFAULT_PHASES) ||
(fobj->nfs_obj.nfs_phases & NFS_PHASE_SQRT))
{
uint32 retcode;
// msieve: find factors
flags = 0;
flags = flags | MSIEVE_FLAG_USE_LOGFILE;
if (VFLAG > 0)
flags = flags | MSIEVE_FLAG_LOG_TO_STDOUT;
flags = flags | MSIEVE_FLAG_NFS_SQRT;
obj->flags = flags;
if (VFLAG >= 0)
printf("nfs: commencing msieve sqrt\n");
logprint_oc(fobj->flogname, "a", "nfs: commencing msieve sqrt\n");
// try this hack - store a pointer to the msieve obj so that
// we can change a flag on abort in order to interrupt the sqrt.
obj_ptr = obj;
retcode = nfs_find_factors(obj, fobj->nfs_obj.gmp_n, &factor_list);
obj_ptr = NULL;
if (retcode)
{
extract_factors(&factor_list,fobj);
if (mpz_cmp_ui(fobj->nfs_obj.gmp_n, 1) == 0)
nfs_state = NFS_STATE_CLEANUP; //completely factored, clean up everything
else
nfs_state = NFS_STATE_DONE; //not factored completely, keep files and stop
}
else
{
if (VFLAG >= 0)
{
printf("nfs: failed to find factors... possibly no dependencies found\n");
printf("nfs: continuing with sieving\n");
}
logprint_oc(fobj->flogname, "a", "nfs: failed to find factors... "
"possibly no dependencies found\n"
"nfs: continuing with sieving\n");
nfs_state = NFS_STATE_SIEVE;
}
}
else
nfs_state = NFS_STATE_DONE; //not factored completely, keep files and stop
break;
case NFS_STATE_CLEANUP:
remove(fobj->nfs_obj.outputfile);
remove(fobj->nfs_obj.fbfile);
sprintf(tmpstr, "%s.p",fobj->nfs_obj.outputfile); remove(tmpstr);
sprintf(tmpstr, "%s.br",fobj->nfs_obj.outputfile); remove(tmpstr);
sprintf(tmpstr, "%s.cyc",fobj->nfs_obj.outputfile); remove(tmpstr);
sprintf(tmpstr, "%s.dep",fobj->nfs_obj.outputfile); remove(tmpstr);
sprintf(tmpstr, "%s.hc",fobj->nfs_obj.outputfile); remove(tmpstr);
sprintf(tmpstr, "%s.mat",fobj->nfs_obj.outputfile); remove(tmpstr);
sprintf(tmpstr, "%s.lp",fobj->nfs_obj.outputfile); remove(tmpstr);
sprintf(tmpstr, "%s.d",fobj->nfs_obj.outputfile); remove(tmpstr);
sprintf(tmpstr, "%s.mat.chk",fobj->nfs_obj.outputfile); remove(tmpstr);
gettimeofday(&stop, NULL);
difference = my_difftime (&start, &stop);
t_time = ((double)difference->secs + (double)difference->usecs / 1000000);
free(difference);
if (VFLAG >= 0)
printf("NFS elapsed time = %6.4f seconds.\n",t_time);
logprint_oc(fobj->flogname, "a", "NFS elapsed time = %6.4f seconds.\n",t_time);
logprint_oc(fobj->flogname, "a", "\n");
logprint_oc(fobj->flogname, "a", "\n");
// free stuff
nfs_state = NFS_STATE_DONE;
break;
case NFS_STATE_DONE:
process_done = 1;
break;
case NFS_STATE_FILTCHECK:
if (job.current_rels >= job.min_rels)
{
if (VFLAG > 0)
printf("nfs: found %u relations, need at least %u, proceeding with filtering ...\n",
job.current_rels, job.min_rels);
nfs_state = NFS_STATE_FILTER;
}
else
{
// compute eta by dividing how many rels we have left to find
// by the average time per relation. we have average time
// per relation because we've saved the time it took to do
// the last batch of sieving and we know how many relations we
// found in that batch.
uint32 est_time;
gettimeofday(&bstop, NULL);
difference = my_difftime (&bstart, &bstop);
t_time = ((double)difference->secs + (double)difference->usecs / 1000000);
free(difference);
est_time = (uint32)((job.min_rels - job.current_rels) *
(t_time / (job.current_rels - pre_batch_rels)));
// if the user doesn't want to sieve, then we can't make progress.
if ((fobj->nfs_obj.nfs_phases == NFS_DEFAULT_PHASES) ||
(fobj->nfs_obj.nfs_phases & NFS_PHASE_SIEVE))
{
if (VFLAG > 0)
printf("nfs: found %u relations, need at least %u "
"(filtering ETA: %uh %um), continuing with sieving ...\n", // uh... um... hmm... idk *shrug*
job.current_rels, job.min_rels, est_time / 3600,
(est_time % 3600) / 60);
nfs_state = NFS_STATE_SIEVE;
}
else
{
if (VFLAG > 0)
printf("nfs: found %u relations, need at least %u "
"(filtering ETA: %uh %um), sieving not selected, finishing ...\n",
job.current_rels, job.min_rels, est_time / 3600,
(est_time % 3600) / 60);
nfs_state = NFS_STATE_DONE;
}
}
break;
case NFS_STATE_STARTNEW:
nfs_state = NFS_STATE_POLY;
// create a new directory for this job
//#ifdef _WIN32
// sprintf(tmpstr, "%s\%s", fobj->nfs_obj.ggnfs_dir,
// mpz_conv2str(&gstr1.s, 10, fobj->nfs_obj.gmp_n));
// mkdir(tmpstr);
//#else
// sprintf(tmpstr, "%s/%s", fobj->nfs_obj.ggnfs_dir,
// mpz_conv2str(&gstr1.s, 10, fobj->nfs_obj.gmp_n));
// mkdir(tmpstr, S_IRWXU);
//#endif
// point msieve and ggnfs to the new directory
//#ifdef _WIN32
// sprintf(fobj->nfs_obj.outputfile, "%s\%s",
// tmpstr, fobj->nfs_obj.outputfile);
// sprintf(fobj->nfs_obj.logfile, "%s\%s",
// tmpstr, fobj->nfs_obj.logfile);
// sprintf(fobj->nfs_obj.fbfile, "%s\%s",
// tmpstr, fobj->nfs_obj.fbfile);
//#else
// sprintf(fobj->nfs_obj.outputfile, "%s%s",
// tmpstr, fobj->nfs_obj.outputfile);
// sprintf(fobj->nfs_obj.logfile, "%s%s",
// tmpstr, fobj->nfs_obj.logfile);
// sprintf(fobj->nfs_obj.fbfile, "%s%s",
// tmpstr, fobj->nfs_obj.fbfile);
//
//#endif
//
// msieve_obj_free(fobj->nfs_obj.mobj);
// obj = msieve_obj_new(input, flags, fobj->nfs_obj.outputfile, fobj->nfs_obj.logfile,
// fobj->nfs_obj.fbfile, g_rand.low, g_rand.hi, (uint32)0, nfs_lower, nfs_upper, cpu,
// (uint32)L1CACHE, (uint32)L2CACHE, (uint32)THREADS, (uint32)0, (uint32)0, 0.0);
// fobj->nfs_obj.mobj = obj;
//
// printf("output: %s\n", fobj->nfs_obj.mobj->savefile.name);
// printf("log: %s\n", fobj->nfs_obj.mobj->logfile_name);
// printf("fb: %s\n", fobj->nfs_obj.mobj->nfs_fbfile_name);
break;
// should really be "resume_job", since we do more than just resume sieving...
case NFS_STATE_RESUMESIEVE:
// last_specialq == 0 if:
// 1) user specifies -R and -ns with params
// 2) user specifies post processing steps only
// 3) user wants to resume sieving (either with a solo -ns or no arguements)
// but no data file or special-q was found
// 4) -R was not specified (but then we won't be in this state, we'll be in DONE)
// last_specialq > 1 if:
// 5) user wants to resume sieving (either with a solo -ns or no arguements)
// and a data file and special-q was found
// 6) it contains poly->time info (in which case we'll be in NFS_STATE_RESUMEPOLY)
strcpy(tmpstr, "");
if ((last_specialq == 0) &&
((fobj->nfs_obj.nfs_phases == NFS_DEFAULT_PHASES) ||
(fobj->nfs_obj.nfs_phases & NFS_PHASE_SIEVE)))
{
// this if-block catches cases 1 and 3 from above
uint32 missing_params = parse_job_file(fobj, &job);
// set min_rels.
get_ggnfs_params(fobj, &job);
fill_job_file(fobj, &job, missing_params);
// if any ggnfs params are missing, fill them
// this means the user can provide an SNFS poly or external GNFS poly,
// but let YAFU choose the other params
// this won't override any params in the file.
if (fobj->nfs_obj.startq > 0)
{
job.startq = fobj->nfs_obj.startq;
sprintf(tmpstr, "nfs: resuming with sieving at user specified special-q %u\n",
job.startq);
}
else
{
// this is a guess, may be completely wrong
job.startq = (job.poly->side == RATIONAL_SPQ ? job.rlim : job.alim) / 2;
sprintf(tmpstr, "nfs: continuing with sieving - could not determine "
"last special q; using default startq\n");
}
// next step is sieving
nfs_state = NFS_STATE_SIEVE;
}
else if ((last_specialq == 0) &&
((fobj->nfs_obj.nfs_phases & NFS_PHASE_FILTER) ||
(fobj->nfs_obj.nfs_phases & NFS_PHASE_LA) ||
(fobj->nfs_obj.nfs_phases & NFS_PHASE_LA_RESUME) ||
(fobj->nfs_obj.nfs_phases & NFS_PHASE_SQRT)))
{
// this if-block catches case 2 from above
// with these options we don't check for the last special-q, so this isn't
// really a new factorization
if ((fobj->nfs_obj.nfs_phases & NFS_PHASE_FILTER))
{
nfs_state = NFS_STATE_FILTCHECK;
sprintf(tmpstr, "nfs: resuming with filtering\n");
}
else if ((fobj->nfs_obj.nfs_phases & NFS_PHASE_LA) ||
(fobj->nfs_obj.nfs_phases & NFS_PHASE_LA_RESUME))
{
nfs_state = NFS_STATE_LINALG;
sprintf(tmpstr, "nfs: resuming with linear algebra\n");
}
else if (fobj->nfs_obj.nfs_phases & NFS_PHASE_SQRT)
{
nfs_state = NFS_STATE_SQRT;
sprintf(tmpstr, "nfs: resuming with sqrt\n");
}
}
else // data file already exists
{
// this if-block catches case 5 from above
(void) parse_job_file(fobj, &job);
// set min_rels.
get_ggnfs_params(fobj, &job);
if (fobj->nfs_obj.startq > 0)
{
// user wants to resume sieving.
// i don't believe this case is ever executed...
// because if startq is > 0, then last_specialq will be 0...
job.startq = fobj->nfs_obj.startq;
nfs_state = NFS_STATE_SIEVE;
}
else
{
job.startq = last_specialq;
// we found some relations - find the appropriate state
// given user input
if ((fobj->nfs_obj.nfs_phases == NFS_DEFAULT_PHASES) ||
(fobj->nfs_obj.nfs_phases & NFS_PHASE_FILTER))
{
nfs_state = NFS_STATE_FILTCHECK;
sprintf(tmpstr, "nfs: resuming with filtering\n");
}
else if (fobj->nfs_obj.nfs_phases & NFS_PHASE_SIEVE)
{
nfs_state = NFS_STATE_SIEVE;
sprintf(tmpstr, "nfs: resuming with sieving at special-q = %u\n",
last_specialq);
}
else if ((fobj->nfs_obj.nfs_phases & NFS_PHASE_LA) ||
(fobj->nfs_obj.nfs_phases & NFS_PHASE_LA_RESUME))
{
nfs_state = NFS_STATE_LINALG;
sprintf(tmpstr, "nfs: resuming with linear algebra\n");
}
else if (fobj->nfs_obj.nfs_phases & NFS_PHASE_SQRT)
{
nfs_state = NFS_STATE_SQRT;
sprintf(tmpstr, "nfs: resuming with sqrt\n");
}
}
}
if (VFLAG >= 0)
printf("%s", tmpstr);
logprint_oc(fobj->flogname, "a", "%s", tmpstr);
// if there is a job file and the user has specified -np, print
// this warning.
if (fobj->nfs_obj.nfs_phases & NFS_PHASE_POLY)
{
printf("WARNING: .job file exists! If you really want to redo poly selection,"
" delete the .job file.\n");
// non ideal solution to infinite loop in factor() if we return without factors
// (should return error code instead)
NFS_ABORT = 1;
process_done = 1;
}
break;
case NFS_STATE_RESUMEPOLY:
if (VFLAG > 1) printf("nfs: resuming poly select\n");
fobj->nfs_obj.polystart = job.last_leading_coeff;
nfs_state = NFS_STATE_POLY;
break;
default:
printf("unknown state, bailing\n");
// non ideal solution to infinite loop in factor() if we return without factors
// (should return error code instead)
NFS_ABORT = 1;
break;
}
//after every state, check elasped time against a specified timeout value
gettimeofday(&stop, NULL);
difference = my_difftime (&start, &stop);
t_time = ((double)difference->secs + (double)difference->usecs / 1000000);
free(difference);
if ((fobj->nfs_obj.timeout > 0) && (t_time > (double)fobj->nfs_obj.timeout))
{
if (VFLAG >= 0)
printf("NFS timeout after %6.4f seconds.\n",t_time);
logprint_oc(fobj->flogname, "a", "NFS timeout after %6.4f seconds.\n",t_time);
process_done = 1;
}
if (NFS_ABORT)
{
print_factors(fobj);
exit(1);
}
}
//reset signal handler to default (no handler).
signal(SIGINT,NULL);
if (obj != NULL)
msieve_obj_free(obj);
free(input);
if( job.snfs )
{
snfs_clear(job.snfs);
free(job.snfs);
}
else if( job.poly )
{
mpz_polys_free(job.poly);
free(job.poly);
}
return;
}
int test_sieve(fact_obj_t* fobj, void* args, int njobs, int are_files)
/* if(are_files), then treat args as a char** list of (external) polys
* else args is a nfs_job_t* array of job structs
* the latter is preferred */
// @ben: the idea is a new yafu function "testsieve(n, ...)" where args are
// an arbitrary list of files of external polys
{
uint32 count;
int i, minscore_id = 0;
double* score = (double*)malloc(njobs * sizeof(double));
double t_time, min_score = 999999999.;
char orig_name[GSTR_MAXSIZE]; // don't clobber fobj->nfs_obj.job_infile
char time[80];
uint32 spq_range = 2000, actual_range;
FILE *flog;
char** filenames; // args
nfs_job_t* jobs; // args
struct timeval stop, stop2; // stop time of this job
struct timeval start, start2; // start time of this job
TIME_DIFF * difference;
if( score == NULL )
{
printf("Couldn't alloc memory!\n");
exit(-1);
}
// check to make sure we can find ggnfs sievers
if (check_for_sievers(fobj, 0) == 1)
{
printf("test: can't find ggnfs lattice sievers - aborting test sieving\n");
return -1;
}
gettimeofday(&start2, NULL);
strcpy(orig_name, fobj->nfs_obj.job_infile);
// necessary because parse/fill_job_file() get filename from fobj
if( are_files )
{ // read files into job structs (get fblim)
filenames = (char**) args;
jobs = (nfs_job_t*)malloc(njobs * sizeof(nfs_job_t));
if( jobs == NULL )
{
printf("Couldn't alloc memory!\n");
exit(-1);
}
memset(jobs, 0, njobs*sizeof(nfs_job_t));
for(i = 0; i < njobs; i++)
{
uint32 missing_params;
strcpy(fobj->nfs_obj.job_infile, filenames[i]);
missing_params = parse_job_file(fobj, jobs+i); // get fblim
get_ggnfs_params(fobj, jobs+i); // get siever
if( missing_params )
{
if( VFLAG >= 0 )
printf("test: warning: \"%s\" is missing some paramters (%#X). filling them.\n",
filenames[i], missing_params);
fill_job_file(fobj, jobs+i, missing_params);
}
// adjust a/rlim, lpbr/a, and mfbr/a if advantageous
skew_snfs_params(fobj, jobs+i);
}
}
else
{ // create poly files
jobs = (nfs_job_t *) args;
filenames = (char**)malloc(njobs*sizeof(char*));
if( !filenames )
{
printf("malloc derped it up!\n");
exit(-1);
}
for(i = 0; i < njobs; i++)
{
FILE* out;
filenames[i] = (char*)malloc(GSTR_MAXSIZE);
if( !filenames[i] )
{
printf("malloc failed\n");
exit(-1);
}
sprintf(filenames[i], "test-sieve-%d.poly", i);
out = fopen(filenames[i], "w");
if( !out )
{
printf("test: couldn't open %s for writing, aborting test sieve\n", filenames[i]);
return -1;
}
if( jobs[i].snfs )
print_snfs(jobs[i].snfs, out);
else
{
gmp_fprintf(out, "n: %Zd\n", fobj->nfs_obj.gmp_n);
print_poly(jobs[i].poly, out);
}
fclose(out);
strcpy(fobj->nfs_obj.job_infile, filenames[i]);
fill_job_file(fobj, jobs+i, PARAM_FLAG_ALL);
}
// that seems like a lot more code than it should be
}
strcpy(fobj->nfs_obj.job_infile, orig_name);
// now we can get to the actual testing
for(i = 0; i < njobs; i++)
{
char syscmd[GSTR_MAXSIZE], tmpbuf[GSTR_MAXSIZE], side[32];
FILE* in;
// should probably scale the range of special-q to test based
// on input difficulty, but not sure how to do that easily...
if( jobs[i].poly->side == RATIONAL_SPQ)
{
sprintf(side, "rational");
jobs[i].startq = jobs[i].rlim; // no reason to test sieve *inside* the fb
}
else
{
sprintf(side, "algebraic");
jobs[i].startq = jobs[i].alim; // ditto
}
flog = fopen(fobj->flogname, "a");
//create the afb/rfb - we don't want the time it takes to do this to
//pollute the sieve timings
sprintf(syscmd, "%s -b %s -k -c 0 -F", jobs[i].sievername, filenames[i]);
if (VFLAG > 0) printf("\ntest: generating factor bases\n");
gettimeofday(&start, NULL);
system(syscmd);
gettimeofday(&stop, NULL);
difference = my_difftime (&start, &stop);
t_time = ((double)difference->secs + (double)difference->usecs / 1000000);
free(difference);
if (VFLAG > 0) printf("test: fb generation took %6.4f seconds\n", t_time);
logprint(flog, "test: fb generation took %6.4f seconds\n", t_time);
MySleep(.1);
//start the test
sprintf(syscmd,"%s%s -%c %s -f %u -c %u -o %s.out",
jobs[i].sievername, VFLAG>0?" -v":"", side[0], filenames[i], jobs[i].startq, spq_range, filenames[i]);
if (VFLAG > 0) printf("test: commencing test sieving of polynomial %d on the %s side over range %u-%u\n", i,
side, jobs[i].startq, jobs[i].startq + spq_range);
logprint(flog, "test: commencing test sieving of polynomial %d on the %s side over range %u-%u\n", i,
side, jobs[i].startq, jobs[i].startq + spq_range);
print_job(&jobs[i], flog);
fclose(flog);
gettimeofday(&start, NULL);
system(syscmd);
gettimeofday(&stop, NULL);
difference = my_difftime (&start, &stop);
t_time = ((double)difference->secs + (double)difference->usecs / 1000000);
free(difference);
//count relations
sprintf(tmpbuf, "%s.out", filenames[i]);
in = fopen(tmpbuf, "r");
actual_range = 0;
count = 0;
if( !in )
{
score[i] = 999999999.;
//est = 7*365*24*3600; // 7 years seems like a nice round number
}
else
{
// scan the data file and
// 1) count the relations
// 2) save the last four relations to a buffer in order to extract the last processed
// special-q.
// we need both 1) and 2) to compute yield correctly.
char **lines, *ptr, tmp[GSTR_MAXSIZE];
int line;
int j;
lines = (char **)malloc(4 * sizeof(char *));
for (j=0; j < 4; j++)
lines[j] = (char *)malloc(GSTR_MAXSIZE * sizeof(char));
line = 0;
count = 0;
while (1)
{
// read a line into the next position of the circular buffer
ptr = fgets(tmp, GSTR_MAXSIZE, in);
if (ptr == NULL)
break;
// quick check that it might be a valid line
if (strlen(tmp) > 30)
{
// wrap
if (++line > 3) line = 0;
// then copy
strcpy(lines[line], tmp);
}
count++;
}
fclose(in);
line = get_spq(lines, line, fobj);
actual_range = line - jobs[i].startq;
if (VFLAG > 0)
printf("test: found %u relations in a range of %u special-q\n",
count, actual_range);
if (actual_range > spq_range)
actual_range = spq_range;
for (j=0; j < 4; j++)
free(lines[j]);
free(lines);
score[i] = t_time / count;
// use estimated sieving time to rank, not sec/rel, since the latter
// is a function of parameterization and therefore not directly comparable
// to each other.
score[i] = (score[i] * jobs[i].min_rels * 1.25) / THREADS;
// be conservative about estimates
}
flog = fopen(fobj->flogname, "a");
if( score[i] < min_score )
{
minscore_id = i;
min_score = score[i];
if (VFLAG > 0) printf("test: new best estimated total sieving time = %s (with %d threads)\n",
time_from_secs(time, (unsigned long)score[i]), THREADS);
logprint(flog, "test: new best estimated total sieving time = %s (with %d threads)\n",
time_from_secs(time, (unsigned long)score[i]), THREADS);
// edit lbpr/a depending on test results. we target something around 2 rels/Q.
// could also change siever version in more extreme cases.
if (count > 4*actual_range)
{
if (VFLAG > 0)
printf("test: yield greater than 4x/spq, reducing lpbr/lpba\n");
jobs[i].lpba--;
jobs[i].lpbr--;
jobs[i].mfba -= 2;
jobs[i].mfbr -= 2;
}
if (count > 8*actual_range)
{
char *pos;
int siever;
pos = strstr(jobs[i].sievername, "gnfs-lasieve4I");
siever = (pos[14] - 48) * 10 + (pos[15] - 48);
if (VFLAG > 0)
printf("test: yield greater than 8x/spq, reducing siever version\n");
switch (siever)
{
case 11:
if (VFLAG > 0) printf("test: siever version cannot be decreased further\n");
jobs[i].snfs->siever = 11;
break;
case 12:
pos[15] = '1';
jobs[i].snfs->siever = 11;
break;
case 13:
pos[15] = '2';
jobs[i].snfs->siever = 12;
break;
case 14:
pos[15] = '3';
jobs[i].snfs->siever = 13;
break;
case 15:
pos[15] = '4';
jobs[i].snfs->siever = 14;
break;
case 16:
pos[15] = '5';
jobs[i].snfs->siever = 15;
break;
}
}
if (count < actual_range)
{
if (VFLAG > 0)
printf("test: yield less than 1x/spq, increasing lpbr/lpba\n");
jobs[i].lpba++;
jobs[i].lpbr++;
jobs[i].mfba += 2;
jobs[i].mfbr += 2;
}
if (count < (actual_range/2))
{
char *pos;
int siever;
pos = strstr(jobs[i].sievername, "gnfs-lasieve4I");
siever = (pos[14] - 48) * 10 + (pos[15] - 48);
if (VFLAG > 0)
printf("test: yield less than 1x/2*spq, increasing siever version\n");
switch (siever)
{
case 16:
if (VFLAG > 0) printf("test: siever version cannot be increased further\n");
jobs[i].snfs->siever = 16;
break;
case 15:
pos[15] = '6';
jobs[i].snfs->siever = 16;
break;
case 14:
pos[15] = '5';
jobs[i].snfs->siever = 15;
break;
case 13:
pos[15] = '4';
jobs[i].snfs->siever = 14;
break;
case 12:
pos[15] = '3';
jobs[i].snfs->siever = 13;
break;
case 11:
pos[15] = '2';
jobs[i].snfs->siever = 12;
break;
}
}
}
else
{
if (VFLAG > 0) printf("test: estimated total sieving time = %s (with %d threads)\n",
time_from_secs(time, (unsigned long)score[i]), THREADS);
logprint(flog, "test: estimated total sieving time = %s (with %d threads)\n",
time_from_secs(time, (unsigned long)score[i]), THREADS);
}
fclose(flog);
remove(tmpbuf); // clean up after ourselves
sprintf(tmpbuf, "%s", filenames[i]);
remove(tmpbuf);
sprintf(tmpbuf, "%s.afb.0", filenames[i]);
remove(tmpbuf);
}
// clean up memory allocated
if( are_files )
{
for(i = 0; i < njobs; i++)
{
mpz_polys_free(jobs[i].poly);
free(jobs[i].poly);
}
free(jobs);
}
else
{
for(i = 0; i < njobs; i++)
free(filenames[i]);
free(filenames);
}
flog = fopen(fobj->flogname, "a");
gettimeofday(&stop2, NULL);
difference = my_difftime (&start2, &stop2);
t_time = ((double)difference->secs + (double)difference->usecs / 1000000);
free(difference);
if (VFLAG > 0) printf("test: test sieving took %1.2f seconds\n", t_time);
logprint(flog, "test: test sieving took %1.2f seconds\n", t_time);
return minscore_id;
}