int main()
{
uint64_t start = 0;
uint64_t stop = 1000;
size_t i;
size_t size;
/* store the primes below 1000 */
int* primes = (int*) primesieve_generate_primes(start, stop, &size, INT_PRIMES);
for (i = 0; i < size; i++)
printf("%i\n", primes[i]);
primesieve_free(primes);
uint64_t n = 1000;
/* store the first 1000 primes */
primes = (int*) primesieve_generate_n_primes(n, start, INT_PRIMES);
for (i = 0; i < n; i++)
printf("%i\n", primes[i]);
primesieve_free(primes);
return 0;
}
int main(void) {
size_t size;
uint64_t *primes = primesieve_generate_primes(5, MAX + 100, &size, UINT64_PRIMES);
if(!primes) {
puts("Could not allocate primes.");
return 1;
}
uint64_t s = 0;
for(uint64_t i = 0, p1, p2, t;; ++i) {
p1 = primes[i];
if(p1 > MAX) {
break;
}
p2 = primes[i + 1];
t = l10(p1);
s += p2*moddiv(p1, p2, t);
}
primesieve_free(primes);
printf("%"PRIu64"\n", s);
}
int main(int argc, char **argv)
{
mpz_t min, rop, sievesize;
unsigned long r;
unsigned long loop_count = 0;
FILE *fp = stdout;
bool *sieve[128];
int *primes, *primes_start, *sieve_loc;
size_t prime_size, loc_size;
mpz_init(min);
mpz_init(rop);
mpz_init(sievesize);
mpz_set_str(min, argv[1], 0);
mpz_set_ui(sievesize, SIEVESIZE);
r = mpz_fdiv_ui(min, PRIMORAL);
r = (97 - r + PRIMORAL) % PRIMORAL;
mpz_add_ui(rop, min, r);
primes_start =
(int *) primesieve_generate_primes(0, MAX_SIEVE_PRIME, &prime_size,
INT_PRIMES);
for (primes = primes_start; *primes <= 7; primes++);
prime_size -= (primes - primes_start);
//loc_size = 6 * prime_size;
loc_size = 8 * prime_size; //padding
sieve_loc = (int *) malloc(sizeof(int) * loc_size);
struct timeval start_t;
struct timeval end_t;
gettimeofday(&start_t, NULL);
#pragma omp parallel
{
mpz_t candidate_plus;
mpz_init(candidate_plus);
int tid = omp_get_thread_num();
sieve[tid] = (bool *) malloc(sizeof(bool) * SIEVESIZE);
if(sieve[tid]==NULL)
printf("%d nil\n", tid);
memset(sieve[tid], true, SIEVESIZE);
#pragma omp for schedule(static, 16)
for (int i = 0; i < prime_size; i++) {
//printf("%d:%d\n",tid,i);
int p = primes[i];
int inv = modinv_i(PRIMORAL, p);
for (int j = 0; j < 6; j++) {
mpz_add_ui(candidate_plus, rop, offsets[j]);
unsigned long cmodp = mpz_fdiv_ui(candidate_plus, p);
int index = ((p - cmodp) * inv) % p;
sieve_loc[i * 8 + j] = index;
}
}
mpz_clear(candidate_plus);
}
gettimeofday(&end_t, NULL);
float duration =
(end_t.tv_sec - start_t.tv_sec) * 1E6 + (end_t.tv_usec -
start_t.tv_usec);
printf("running time:%f\n", duration);
mpz_t tmp[4];
mpz_t candidate[4];
mpz_init(tmp[0]);
mpz_init(tmp[1]);
mpz_init(tmp[2]);
mpz_init(tmp[3]);
mpz_init(candidate[0]);
mpz_init(candidate[1]);
mpz_init(candidate[2]);
mpz_init(candidate[3]);
while (1) {
//step 1
//printf("Sieving\n");
gettimeofday(&start_t, NULL);
for (int i = 0; i < prime_size; i++) {
//printf("thread %d:prime%d\n", tid, primes[i]);
for (int j = 0; j < 6; j++) {
//o = sieve_loc[sieve_loc_index];
unsigned int o = sieve_loc[8 * i + j];
while (o < SIEVESIZE) {
sieve[0][o] = false;
o += primes[i];
}
sieve_loc[8 * i + j] = o - SIEVESIZE;
}
}
/*for(int i=0;i<SIEVESIZE;i++)
if(sieve[0][i])
printf("1\n");
else
printf("0\n");
for(int i=0;i<prime_size;i++){
for(int j=0;j<6;j++)
printf("%d:%d\n",primes[i], sieve_loc[8*i+j]);
}
break;*/
gettimeofday(&end_t, NULL);
duration =
(end_t.tv_sec - start_t.tv_sec) * 1E6 + (end_t.tv_usec -
start_t.tv_usec);
printf("running time1:%f\n", duration);
gettimeofday(&start_t, NULL);
#pragma omp parallel
{
int tid = omp_get_thread_num();
//int num = omp_get_num_threads();
/*#pragma omp for
for (int i = 0; i < prime_size; i++) {
//printf("thread %d:prime%d\n", tid, primes[i]);
for (int j = 0; j < 6; j++) {
//o = sieve_loc[sieve_loc_index];
unsigned int o = sieve_loc[8 * i + j];
while (o < SIEVESIZE) {
sieve[tid][o] = false;
o += primes[i];
}
sieve_loc[8 * i + j] = o - SIEVESIZE;
}
}*/
//#pragma omp barrier
#pragma omp for
for (int i = 0; i < SIEVESIZE; i++) {
/*bool flag = true;
for (int j = 0; j < num; j++) {
flag = flag && sieve[j][i];
sieve[j][i] = true;
}*/
if (sieve[0][i]) {
mpz_set_ui(tmp[tid], i);
mpz_addmul_ui(tmp[tid], sievesize, loop_count);
mpz_set(candidate[tid], rop);
mpz_addmul_ui(candidate[tid], tmp[tid], PRIMORAL);
if (is_fermat_valid(candidate[tid])) {
mpz_out_str(fp, 16, candidate[tid]);
exit(0);
}
}
//printf("thread %d:i%d\n", tid, i);
if(!sieve[0][i])
sieve[0][i] = true;
}
/*#pragma omp barrier
#pragma omp for
for (int i = 0; i < prime_size; i++) {
for (int j = 0; j < 6; j++)
sieve[tid][i*8+j]=true;
}*/
}
gettimeofday(&end_t, NULL);
duration =
(end_t.tv_sec - start_t.tv_sec) * 1E6 + (end_t.tv_usec -
start_t.tv_usec);
printf("running time2:%f\n", duration);
loop_count++;
}
return 0;
}
SV* primesieve(SV *start_sv, SV *limit_sv, int run_mode, int fd)
{
AV *ret;
uint64_t n_ret, start, limit, *primes;
size_t size, i;
int err;
#ifdef __LP64__
start = SvUV(start_sv);
limit = SvUV(limit_sv);
#else
start = strtoull(SvPV_nolen(start_sv), NULL, 10);
limit = strtoull(SvPV_nolen(limit_sv), NULL, 10);
#endif
ret = newAV(), n_ret = 0, err = 0;
//====================================================================
// Count primes, sum primes, otherwise output primes for this block.
//====================================================================
if (run_mode == MODE_COUNT) {
n_ret = primesieve_count_primes(start, limit);
}
else {
primes = primesieve_generate_primes(start, limit, &size, UINT64_PRIMES);
if (run_mode == MODE_SUM) {
for (i = 0; i < size; i++)
n_ret += primes[i];
}
else {
char *buf; int len;
buf = (char *) malloc(sizeof(char) * (FLUSH_LIMIT + 216));
len = 0;
for (i = 0; i < size; i++) {
if ((err = write_output(fd, buf, primes[i], &len)))
break;
}
if (!err)
err = flush_output(fd, buf, &len);
free((void *) buf);
buf = NULL;
}
primesieve_free(primes);
}
//====================================================================
// Return.
//====================================================================
if (run_mode == MODE_PRINT) {
av_push(ret, newSViv(err));
}
else {
#ifdef __LP64__
av_push(ret, newSVuv(n_ret));
#else
SV *n_sv; char *ptr; STRLEN len; int n_chars;
n_sv = newSVpvn("", N_MAXDIGITS);
ptr = SvPV(n_sv, len);
n_chars = sprintull(ptr, n_ret);
av_push(ret, newSVpvn(ptr, n_chars));
#endif
}
return newRV_noinc((SV *) ret);
}
