int init_smt(struct s_smc *smc, u_char *mac_addr)
{
int p ;
#if defined(DEBUG) && !defined(DEBUG_BRD)
debug.d_smt = 0 ;
debug.d_smtf = 0 ;
debug.d_rmt = 0 ;
debug.d_ecm = 0 ;
debug.d_pcm = 0 ;
debug.d_cfm = 0 ;
debug.d_plc = 0 ;
#ifdef ESS
debug.d_ess = 0 ;
#endif
#ifdef SBA
debug.d_sba = 0 ;
#endif
#endif
for ( p = 0; p < NUMPHYS; p ++ ) {
smc->y[p].mib = & smc->mib.p[p] ;
}
set_oem_spec_val(smc) ;
(void) smt_set_mac_opvalues(smc) ;
init_fddi_driver(smc,mac_addr) ;
smt_fixup_mib(smc) ;
ev_init(smc) ;
#ifndef SLIM_SMT
smt_init_evc(smc) ;
#endif
smt_timer_init(smc) ;
smt_agent_init(smc) ;
pcm_init(smc) ;
ecm_init(smc) ;
cfm_init(smc) ;
rmt_init(smc) ;
for (p = 0 ; p < NUMPHYS ; p++) {
pcm(smc,p,0) ;
}
ecm(smc,0) ;
cfm(smc,0) ;
rmt(smc,0) ;
smt_agent_task(smc) ;
PNMI_INIT(smc) ;
return(0) ;
}
/*
* Init SMT
*/
int init_smt(struct s_smc *smc, u_char *mac_addr)
/* u_char *mac_addr; canonical address or NULL */
{
int p ;
#if defined(DEBUG) && !defined(DEBUG_BRD)
debug.d_smt = 0 ;
debug.d_smtf = 0 ;
debug.d_rmt = 0 ;
debug.d_ecm = 0 ;
debug.d_pcm = 0 ;
debug.d_cfm = 0 ;
debug.d_plc = 0 ;
#ifdef ESS
debug.d_ess = 0 ;
#endif
#ifdef SBA
debug.d_sba = 0 ;
#endif
#endif /* DEBUG && !DEBUG_BRD */
/* First initialize the ports mib->pointers */
for ( p = 0; p < NUMPHYS; p ++ ) {
smc->y[p].mib = & smc->mib.p[p] ;
}
set_oem_spec_val(smc) ;
(void) smt_set_mac_opvalues(smc) ;
init_fddi_driver(smc,mac_addr) ; /* HW driver */
smt_fixup_mib(smc) ; /* update values that depend on s.sas */
ev_init(smc) ; /* event queue */
#ifndef SLIM_SMT
smt_init_evc(smc) ; /* evcs in MIB */
#endif /* no SLIM_SMT */
smt_timer_init(smc) ; /* timer package */
smt_agent_init(smc) ; /* SMT frame manager */
pcm_init(smc) ; /* PCM state machine */
ecm_init(smc) ; /* ECM state machine */
cfm_init(smc) ; /* CFM state machine */
rmt_init(smc) ; /* RMT state machine */
for (p = 0 ; p < NUMPHYS ; p++) {
pcm(smc,p,0) ; /* PCM A state machine */
}
ecm(smc,0) ; /* ECM state machine */
cfm(smc,0) ; /* CFM state machine */
rmt(smc,0) ; /* RMT state machine */
smt_agent_task(smc) ; /* NIF FSM etc */
PNMI_INIT(smc) ; /* PNMI initialization */
return(0) ;
}
void pm1_init(fact_obj_t *fobj)
{
mpz_init(pm1_data.gmp_n);
mpz_init(pm1_data.gmp_factor);
ecm_init(pm1_data.params);
//gmp_randseed_ui(tdata->params->rng,
// get_rand(&obj->seed1, &obj->seed2));
pm1_data.params->method = ECM_PM1;
//pm1_data.params->verbose = 1;
TMP_STG2_MAX = fobj->pm1_obj.B2;
return;
}
void pp1_init(fact_obj_t *fobj)
{
mpz_init(pp1_data.gmp_n);
mpz_init(pp1_data.gmp_factor);
ecm_init(pp1_data.params);
//gmp_randseed_ui(tdata->params->rng,
// get_rand(&obj->seed1, &obj->seed2));
pp1_data.params->method = ECM_PP1;
//pp1_data.params->verbose = 1;
TMP_STG2_MAX = fobj->pp1_obj.B2; //WILL_STG2_MAX;
PP1_ABORT = 0;
signal(SIGINT,pp1exit);
return;
}
static int check_for_factor2(mpz_t f, mpz_t inputn, mpz_t fmin, mpz_t n, int stage, mpz_t* sfacs, int* nsfacs, int degree)
{
int success, sfaci;
UV B1;
/* Use this so we don't modify their input value */
mpz_set(n, inputn);
if (mpz_cmp(n, fmin) <= 0) return 0;
#if 0
{
/* Straightforward trial division up to 3000. */
PRIME_ITERATOR(iter);
UV tf;
UV const trial_limit = 3000;
for (tf = 2; tf < trial_limit; tf = prime_iterator_next(&iter)) {
if (mpz_cmp_ui(n, tf*tf) < 0) break;
while (mpz_divisible_ui_p(n, tf))
mpz_divexact_ui(n, n, tf);
}
prime_iterator_destroy(&iter);
}
#else
/* Utilize GMP's fast gcd algorithms. Trial to 224737 with two gcds. */
mpz_tdiv_q_2exp(n, n, mpz_scan1(n, 0));
while (mpz_divisible_ui_p(n, 3)) mpz_divexact_ui(n, n, 3);
while (mpz_divisible_ui_p(n, 5)) mpz_divexact_ui(n, n, 5);
if (mpz_cmp(n, fmin) <= 0) return 0;
mpz_gcd(f, n, _gcd_small);
while (mpz_cmp_ui(f, 1) > 0) {
mpz_divexact(n, n, f);
mpz_gcd(f, n, _gcd_small);
}
if (mpz_cmp(n, fmin) <= 0) return 0;
mpz_gcd(f, n, _gcd_large);
while (mpz_cmp_ui(f, 1) > 0) {
mpz_divexact(n, n, f);
mpz_gcd(f, n, _gcd_large);
}
/* Quick stage 1 n-1 using a single big powm + gcd. */
if (stage == 0) {
if (mpz_cmp(n, fmin) <= 0) return 0;
mpz_set_ui(f, 2);
mpz_powm(f, f, _lcm_small, n);
mpz_sub_ui(f, f, 1);
mpz_gcd(f, f, n);
if (mpz_cmp_ui(f, 1) != 0 && mpz_cmp(f, n) != 0) {
mpz_divexact(n, n, f);
if (mpz_cmp(f, n) > 0)
mpz_set(n, f);
}
}
#endif
sfaci = 0;
success = 1;
while (success) {
UV nsize = mpz_sizeinbase(n, 2);
if (mpz_cmp(n, fmin) <= 0) return 0;
if (_GMP_is_prob_prime(n)) { mpz_set(f, n); return (mpz_cmp(f, fmin) > 0); }
success = 0;
B1 = 300 + 3 * nsize;
if (degree <= 2) B1 += nsize; /* D1 & D2 are cheap to prove. Encourage. */
if (degree <= 0) B1 += nsize; /* N-1 and N+1 are really cheap. */
if (degree > 20 && stage <= 1) B1 -= nsize; /* Less time on big polys. */
if (degree > 40) B1 -= nsize/2; /* Less time on big polys. */
if (stage >= 1) {
#ifdef USE_LIBECM
/* TODO: Tune stage 1 (PM1?) */
/* TODO: LIBECM in other stages */
if (!success) {
ecm_params params;
ecm_init(params);
params->method = ECM_ECM;
mpz_set_ui(params->B2, 10*B1);
mpz_set_ui(params->sigma, 0);
success = ecm_factor(f, n, B1/4, params);
ecm_clear(params);
if (mpz_cmp(f, n) == 0) success = 0;
}
#else
if (!success) success = _GMP_pminus1_factor(n, f, B1, 6*B1);
if (!success) success = _GMP_pplus1_factor(n, f, 0, B1/8, B1/8);
if (!success && nsize < 500) success = _GMP_pbrent_factor(n, f, nsize, 1024-nsize);
#endif
}
/* Try any factors found in previous stage 2+ calls */
while (!success && sfaci < *nsfacs) {
if (mpz_divisible_p(n, sfacs[sfaci])) {
mpz_set(f, sfacs[sfaci]);
success = 1;
}
sfaci++;
}
if (stage > 1 && !success) {
if (stage == 2) {
if (!success) success = _GMP_pbrent_factor(n, f, nsize-1, 8192);
if (!success) success = _GMP_pminus1_factor(n, f, 6*B1, 60*B1);
/* p+1 with different initial point and searching farther */
if (!success) success = _GMP_pplus1_factor(n, f, 1, B1/2, B1/2);
if (!success) success = _GMP_ecm_factor_projective(n, f, 250, 3);
} else if (stage == 3) {
if (!success) success = _GMP_pbrent_factor(n, f, nsize+1, 16384);
if (!success) success = _GMP_pminus1_factor(n, f, 60*B1, 600*B1);
/* p+1 with a third initial point and searching farther */
if (!success) success = _GMP_pplus1_factor(n, f, 2, 1*B1, 1*B1);
if (!success) success = _GMP_ecm_factor_projective(n, f, B1/4, 4);
} else if (stage == 4) {
if (!success) success = _GMP_pminus1_factor(n, f, 300*B1, 300*20*B1);
if (!success) success = _GMP_ecm_factor_projective(n, f, B1/2, 4);
} else if (stage >= 5) {
UV B = B1 * (stage-4) * (stage-4) * (stage-4);
if (!success) success = _GMP_ecm_factor_projective(n, f, B, 8+stage);
}
}
if (success) {
if (mpz_cmp_ui(f, 1) == 0 || mpz_cmp(f, n) == 0) {
gmp_printf("factoring %Zd resulted in factor %Zd\n", n, f);
croak("internal error in ECPP factoring");
}
/* Add the factor to the saved factors list */
if (stage > 1 && *nsfacs < MAX_SFACS) {
/* gmp_printf(" ***** adding factor %Zd ****\n", f); */
mpz_init_set(sfacs[*nsfacs], f);
nsfacs[0]++;
}
/* Is the factor f what we want? */
if ( mpz_cmp(f, fmin) > 0 && _GMP_is_prob_prime(f) ) return 1;
/* Divide out f */
mpz_divexact(n, n, f);
}
}
/* n is larger than fmin and not prime */
mpz_set(f, n);
return -1;
}
uint32 ecm_pp1_pm1(msieve_obj *obj, mp_t *n, mp_t *reduced_n,
factor_list_t *factor_list) {
uint32 i, j, max_digits;
uint32 bits;
mpz_t gmp_n, gmp_factor;
pm1_pp1_t non_ecm_vals[NUM_NON_ECM];
uint32 factor_found = 0;
uint32 num_trivial = 0;
ecm_params params;
/* factorization will continue until any remaining
composite cofactors are smaller than the cutoff for
using other methods */
/* initialize */
mpz_init(gmp_n);
mpz_init(gmp_factor);
for (i = 0; i < NUM_NON_ECM; i++) {
pm1_pp1_t *tmp = non_ecm_vals + i;
tmp->stage_1_done = 1.0;
mpz_init_set_ui(tmp->start_val, (unsigned long)0);
}
ecm_init(params);
gmp_randseed_ui(params->rng, get_rand(&obj->seed1, &obj->seed2));
mp2gmp(n, gmp_n);
max_digits = choose_max_digits(obj, mp_bits(n));
/* for each digit level */
for (i = 0; i < NUM_TABLE_ENTRIES; i++) {
const work_t *curr_work = work_table + i;
uint32 log_rate, next_log;
int status;
if (curr_work->digits > max_digits)
break;
logprintf(obj, "searching for %u-digit factors\n",
curr_work->digits);
/* perform P-1. Stage 1 runs much faster for this
algorithm than it does for ECM, so crank up the
stage 1 bound
We save the stage 1 output to reduce the work at
the next digit level */
for (j = 0; j < NUM_PM1_TRIALS; j++) {
pm1_pp1_t *tmp = non_ecm_vals + j;
params->method = ECM_PM1;
params->B1done = tmp->stage_1_done;
mpz_set(params->x, tmp->start_val);
status = ecm_factor(gmp_factor, gmp_n,
10 * curr_work->stage_1_bound, params);
tmp->stage_1_done = params->B1done;
mpz_set(tmp->start_val, params->x);
HANDLE_FACTOR_FOUND("P-1");
}
/* perform P+1. Stage 1 runs somewhat faster for this
algorithm than it does for ECM, so crank up the
stage 1 bound
We save the stage 1 output to reduce the work at
the next digit level */
for (j = 0; j < NUM_PP1_TRIALS; j++) {
pm1_pp1_t *tmp = non_ecm_vals + NUM_PM1_TRIALS + j;
params->method = ECM_PP1;
params->B1done = tmp->stage_1_done;
mpz_set(params->x, tmp->start_val);
status = ecm_factor(gmp_factor, gmp_n,
5 * curr_work->stage_1_bound, params);
tmp->stage_1_done = params->B1done;
mpz_set(tmp->start_val, params->x);
HANDLE_FACTOR_FOUND("P+1");
}
/* run the specified number of ECM curves. Because
so many curves could be necessary, just start each
one from scratch */
log_rate = 0;
if (obj->flags & (MSIEVE_FLAG_USE_LOGFILE |
MSIEVE_FLAG_LOG_TO_STDOUT)) {
if (curr_work->digits >= 35)
log_rate = 1;
else if (curr_work->digits >= 30)
log_rate = 5;
else if (curr_work->digits >= 25)
log_rate = 20;
}
next_log = log_rate;
for (j = 0; j < curr_work->num_ecm_trials; j++) {
params->method = ECM_ECM;
params->B1done = 1.0;
mpz_set_ui(params->x, (unsigned long)0);
mpz_set_ui(params->sigma, (unsigned long)0);
status = ecm_factor(gmp_factor, gmp_n,
curr_work->stage_1_bound, params);
HANDLE_FACTOR_FOUND("ECM");
if (log_rate && j == next_log) {
next_log += log_rate;
fprintf(stderr, "%u of %u curves\r",
j, curr_work->num_ecm_trials);
fflush(stderr);
}
}
if (log_rate)
fprintf(stderr, "\ncompleted %u ECM curves\n", j);
}
clean_up:
ecm_clear(params);
gmp2mp(gmp_n, reduced_n);
mpz_clear(gmp_n);
mpz_clear(gmp_factor);
for (i = 0; i < NUM_NON_ECM; i++)
mpz_clear(non_ecm_vals[i].start_val);
return factor_found;
}
static int check_for_factor(mpz_t f, mpz_t inputn, mpz_t fmin, mpz_t n, int stage, mpz_t* sfacs, int* nsfacs, int degree)
{
int success, sfaci;
UV B1;
/* Use this so we don't modify their input value */
mpz_set(n, inputn);
if (mpz_cmp(n, fmin) <= 0) return 0;
#if 0
/* Use this to really encourage n-1 / n+1 proof types */
if (degree <= 0) {
if (stage == 1) return -1;
if (stage == 0) stage = 1;
}
#endif
/* Utilize GMP's fast gcd algorithms. Trial to 224737+ with two gcds. */
mpz_tdiv_q_2exp(n, n, mpz_scan1(n, 0));
while (mpz_divisible_ui_p(n, 3)) mpz_divexact_ui(n, n, 3);
while (mpz_divisible_ui_p(n, 5)) mpz_divexact_ui(n, n, 5);
if (mpz_cmp(n, fmin) <= 0) return 0;
mpz_gcd(f, n, _gcd_small);
while (mpz_cmp_ui(f, 1) > 0) {
mpz_divexact(n, n, f);
mpz_gcd(f, f, n);
}
if (mpz_cmp(n, fmin) <= 0) return 0;
mpz_gcd(f, n, _gcd_large);
while (mpz_cmp_ui(f, 1) > 0) {
mpz_divexact(n, n, f);
mpz_gcd(f, f, n);
}
sfaci = 0;
success = 1;
while (success) {
UV nsize = mpz_sizeinbase(n, 2);
const int do_pm1 = 1;
const int do_pp1 = 1;
const int do_pbr = 0;
const int do_ecm = 0;
if (mpz_cmp(n, fmin) <= 0) return 0;
if (is_bpsw_prime(n)) { mpz_set(f, n); return (mpz_cmp(f, fmin) > 0); }
success = 0;
B1 = 300 + 3 * nsize;
if (degree <= 2) B1 += nsize; /* D1 & D2 are cheap to prove. */
if (degree <= 0) B1 += 2*nsize; /* N-1 and N+1 are really cheap. */
if (degree > 20 && stage <= 1) B1 -= nsize; /* Less time on big polys. */
if (degree > 40) B1 -= nsize/2; /* Less time on big polys. */
if (stage == 0) {
/* A relatively small performance hit, makes slightly smaller proofs. */
if (nsize < 900 && degree <= 2) B1 *= 1.8;
/* We need to try a bit harder for the large sizes :( */
if (nsize > 1400) B1 *= 2;
if (nsize > 2000) B1 *= 2;
if (!success)
success = _GMP_pminus1_factor(n, f, 100+B1/8, 100+B1);
} else if (stage >= 1) {
/* P-1 */
if ((!success && do_pm1))
success = _GMP_pminus1_factor(n, f, B1, 6*B1);
/* Pollard's Rho */
if ((!success && do_pbr && nsize < 500))
success = _GMP_pbrent_factor(n, f, nsize % 53, 1000-nsize);
/* P+1 */
if ((!success && do_pp1)) {
UV ppB = (nsize < 2000) ? B1/4 : B1/16;
success = _GMP_pplus1_factor(n, f, 0, ppB, ppB);
}
if ((!success && do_ecm))
success = _GMP_ecm_factor_projective(n, f, 400, 2000, 1);
#ifdef USE_LIBECM
/* TODO: LIBECM in other stages */
/* Note: this will be substantially slower than our code for small sizes
* and the small B1/B2 values we're using. */
if (!success && degree <= 2 && nsize > 600) {
ecm_params params;
ecm_init(params);
params->method = ECM_ECM;
mpz_set_ui(params->B2, 10*B1);
mpz_set_ui(params->sigma, 0);
success = ecm_factor(f, n, B1/4, params);
ecm_clear(params);
if (mpz_cmp(f, n) == 0) success = 0;
if (success) { printf("ECM FOUND FACTOR\n"); }
}
#endif
}
/* Try any factors found in previous stage 2+ calls */
while (!success && sfaci < *nsfacs) {
if (mpz_divisible_p(n, sfacs[sfaci])) {
mpz_set(f, sfacs[sfaci]);
success = 1;
}
sfaci++;
}
if (stage > 1 && !success) {
if (stage == 2) {
/* if (!success) success = _GMP_pbrent_factor(n, f, nsize-1, 8192); */
if (!success) success = _GMP_pminus1_factor(n, f, 6*B1, 60*B1);
/* p+1 with different initial point and searching farther */
if (!success) success = _GMP_pplus1_factor(n, f, 1, B1/2, B1/2);
if (!success) success = _GMP_ecm_factor_projective(n, f, 250, 2500, 8);
} else if (stage == 3) {
if (!success) success = _GMP_pbrent_factor(n, f, nsize+1, 16384);
if (!success) success = _GMP_pminus1_factor(n, f, 60*B1, 600*B1);
/* p+1 with a third initial point and searching farther */
if (!success) success = _GMP_pplus1_factor(n, f, 2, 1*B1, 1*B1);
if (!success) success = _GMP_ecm_factor_projective(n, f, B1/4, B1*4, 5);
} else if (stage == 4) {
if (!success) success = _GMP_pminus1_factor(n, f, 300*B1, 300*20*B1);
if (!success) success = _GMP_ecm_factor_projective(n, f, B1/2, B1*8, 4);
} else if (stage >= 5) {
UV B = B1 * (stage-4) * (stage-4) * (stage-4);
if (!success) success = _GMP_ecm_factor_projective(n, f, B, 10*B, 8+stage);
}
}
if (success) {
if (mpz_cmp_ui(f, 1) == 0 || mpz_cmp(f, n) == 0) {
gmp_printf("factoring %Zd resulted in factor %Zd\n", n, f);
croak("internal error in ECPP factoring");
}
/* Add the factor to the saved factors list */
if (stage > 1 && *nsfacs < MAX_SFACS) {
/* gmp_printf(" ***** adding factor %Zd ****\n", f); */
mpz_init_set(sfacs[*nsfacs], f);
nsfacs[0]++;
}
/* Is the factor f what we want? */
if ( mpz_cmp(f, fmin) > 0 && is_bpsw_prime(f) ) return 1;
/* Divide out f */
mpz_divexact(n, n, f);
}
}
/* n is larger than fmin and not prime */
mpz_set(f, n);
return -1;
}