Hard parallelization with #pragma omp to find the Nth prime number - c

Question

The objective of this problem is to be able to get the 2.000.000 first primes and be able to tell which the 2.000.000th prime is.
We start from this code:
#include <stdlib.h>
#include <stdio.h>
#define N 2000000
int p[N];
main(int na,char* arg[])
{
int i;
int pp,num;
printf("Number of primes to find: %d\n",N);
p[0] = 2;
p[1] = 3;
pp = 2;
num = 5;
while (pp < N)
{
for (i=1; p[i]*p[i] <= num ;i++)
if (num % p[i] == 0) break;
if (p[i]*p[i] > num) p[pp++]=num;
num += 2;
}
printf("The %d prime is: %d\n",N,p[N-1]);
exit(0);
}
Now we are asked to make this process threaded with via pragma omp. This is what I've done so far:
#include <stdlib.h>
#include <stdio.h>
#define N 2000000
#define D 1415
int p[N];
main(int na,char* arg[])
{
int i,j;
int pp,num;
printf("Number of primes to find: %d\n",N);
p[0] = 2;
p[1] = 3;
pp = 2;
num = 5;
while (pp < D)
{
for (i=1; p[i]*p[i] <= num ;i++)
if (num % p[i] == 0) break;
if (p[i]*p[i] > num) p[pp++]=num;
num += 2;
}
int success = 0;
int t_num;
int temp_num = num;
int total = pp;
#pragma omp parallel num_threads(4) private(j, t_num, num, success)
{
t_num = omp_get_thread_num();
num = temp_num + t_num*2;
#pragma omp for ordered schedule(static,4)
for(pp=D; pp<N; pp++) {
success = 0;
while(success==0) {
for (i=1; p[i]*p[i] <= num;i++) {
if (num % p[i] == 0) break;
}
if (p[i]*p[i] > num) {
p[pp] = num;
success=1;
}
num+=8;
}
}
}
//sort(p, 0, N);
printf("El %d primer es: %d\n",N,p[N-1]);
exit(0);
}
Now let me explain my "partial" solution, and therefore, my problem.
The first D primes are obtained with sequencial code, so now I can check the divisibility for a large amount of numbers.
Each thread runs a diagonal of primes so that there are no dependencies between threads and there's no need of syncronization. However, the problems with this approach are the following:
One thread may generate more primes than another thread
As a direct consequence of problem 1., it will generate N primes but they won't be ordered, so when the prime counter 'pp' reaches 'N', the last prime is not the 2.000.000th prime, it's a more advanced prime.
It also may be that by the time it generates 2.000.000 primes, the thread who can reach the real 2.000.000th prime may not have enought time to even put it on the prime array 'p'.
And the question/dilemma is:
How I can be able to know when the 2.000.000th prime is generated?
Hints:
I was told that I should do batches of ( let's say ) 10.000 candidates of primes. Then when something I don't know happends, I would know that the last batch of 10.000 candidates contains the 2.000.000th prime and I could just sort it with quicksort.
I hope I made myself clear, this is really tought exercise and I just tried non-stop for several days.

Answer 1

If all you need is 2000000 primes, you can maintain one ~4.1MB sized bitarray and flip bits on it for each found prime. No sort is needed. Halve your bitarray size by implementing odds-only representation scheme.
Use Sieve of Eratosthenes, in segments, with sizes proportional to sqrt(top_value_of_range) (or something similar - the goal is to have approximately same amount of work to be performed on each segment). For n=2000000, n*(log n + log(log n)) == 34366806, and prime[771]^2 == 34421689 (0-based), so, precalculate the first 771 odd primes.
Each worker can count, too, as it flips the bits, so you will know counts for each range when they are all finished, and will only need to scan through the one range that contains the 2mln-th prime, in the end, to find that prime. Or have each worker maintain its own bitarray according to its range - you will only have to keep one, and can discard the others.
The pseudocode for counting Sieve of Eratosthenes is:
Input: an integer n > 1
Let A be an array of bool values, indexed by integers 3, 5, ... upto n,
initially all set to true.
count := floor( (n-1)/2 )
for i = 3, 5, 7, ..., while i^2 ≤ n:
if A[i] is true:
for j = i^2, i^2 + 2i, i^2 + 4i, ..., while j ≤ n:
if A[j] is true:
A[j] := false
count := count - 1
Now all 'i's such that A[i] is true are prime,
and 'count' is the total count of odd primes found.

Answer 2

I can think of two approaches.
Once you've got a candidate for the 2 millionth prime, your threads continue calculating primes that are lower than your candidate until you have no primes missing. Then you can sort the list of primes and take the 2 millionth from that.
If your threads are producing blocks of sequential prime numbers, they should maintain the blocks separately and then the blocks of prime numbers can be subsequently reassembled into a master list. The thread that does the reassembly can terminate the program once it's found the 2 millionth prime.