How to improve forking/joining of multithreading program?

Question

apparenty the OP got their answer already, in the comments, and the issue is resolved now.

I have coded a prime number program (sieve of eratosthenes) that executes using pthreads.

This is my first multithreading program and I don't know why my program takes roughly 3 mins. time to execute. Thats too much time!

Can someone tell me where exactly am I wrong:

#include<iostream>
#include<cstring>
#include<pthread.h>
#include<time.h>

using namespace std;

//set limits
#define  LIMIT   100000001
#define THREAD_LIMIT   8

//declare buffers
bool num[LIMIT];

unsigned long long num_of_prime = 1; // 2 is counted as prime initially 
unsigned long long sum_prime = 2;    // 2 is counted in sum of primes

void *search(void *);

int main()
{
    clock_t start_time = clock(); // start clock stamp

    pthread_t thread[THREAD_LIMIT];
    int thread_val=-1,j=-1;
    unsigned long long i=3;
    bool *max_prime[10];    // stores max. 10 prime numbers

    memset(num,0,LIMIT);    // initialize buffer with 0 

    while(i<LIMIT)
    {
        if(num[i]==0)
        {
            num_of_prime++;
            sum_prime +=i;
            j = ++j%10;
            max_prime[j]=num+i;
            thread_val=++thread_val%THREAD_LIMIT; 
            pthread_join(thread[thread_val],NULL);  // wait till the current thread ends
            pthread_create(&thread[thread_val],NULL,search,(void *)i); // fork thread function to flag composite numbers
        }   
        i+=2;   // only odd numbers
    }

    // end all threads
    for(i=0;i<THREAD_LIMIT;i++)
    {
        pthread_join(thread[i],NULL); 
    }

    cout<<"Execution time: "<<((double)(clock() - start_time))/CLOCKS_PER_SEC<<"\n";
    cout<<"Number of Primes: "<<num_of_prime<<"\n";
    cout<<"Sum of Primes: "<<sum_prime<<"\n";
    cout<<"List of 10 Max. Primes: "<<"\n";
    for(i=0;i<10;i++)
    {
        j=++j%10;
        cout<<(max_prime[j]-num)<<"\n";
    }
    return 0;
}

void *search(void *n)
{
    unsigned long long jump = (unsigned long long int)n;
    unsigned long long position = jump*jump; // Jump to N*N th comppsite number
    bool *posn = num;

    jump<<=1; 
    while(position<LIMIT)
    {

        (*(posn+position))?(position+=jump):(*(posn+position)=1,position+=jump);

    } 
    return NULL;
}

Contraints: Only 8 threads can be forked.

N: 10^8

How can I improve the efficiency of this code (especially in forking & joining the threads)?

Answer 1

My experience is that throwing some threads at the problem speeds things up, but disappointingly little, for primes up to a large N.

I tried splitting up the sieve into chunks, one per thread. One thread generates a list of primes up to sqrt(N), then all threads crunch away at their part of the sieve, knocking out multiples of the primes. The idea was to have as little interaction between the threads as possible -- they all crunch away at their portion of the sieve, independently.

Your code appears to start a new thread to knock out the multiples for each prime found. The overhead of starting/stopping that many threads fills me with dismay ! I'm damned if I can see how you avoid having the threads trip over each other -- but I assume they don't ?

FWIW, for primes up to 10^8, I manage:

• unthreaded: 0.160 secs elapsed, 0.140 secs user

• 5 threads: 0.040 secs elapsed, 0.130 secs user.

on a relatively modest x86_64 machine.

For 10^10:

• unthreaded: 39.260 secs elapsed, 37.910 secs user

• 5 threads: 23.680 secs elapsed, 110.120 secs user.

which is deeply disappointing. I think the problem is that the cache is being swamped... the code processes each prime in turn and knocks out all its multiples, so is sweeping from one end of a chunk to the other, and then going back to the beginning. It may actually be better to bang away at, say, 512K of the sieve, for all primes, and then repeat.