How do I chunk prime numbers for multithreading?

Question

I'm relatively new to C, and up until now had barely any experience in multithreading. I've written a small program that calculates whether an array of numbers are primes or composites. This works fine, but when working with larger numbers I'd like to split the workload between threads.

I sort of have an idea of how this would work, I just can't see how to implement this within C. As a simple example if we take the prime 199, I would divide this number by the number of cores (e.g. 4) to get 49.75. We would then round this number to 50. Each thread would then be given a range to calculate.

The first thread would calculate from i 2 to 50, the second from i 51 to 102, and so on.

I hope that makes some sense, I'm sure the solution is easier than I think it is, it's just I can't for the life of me work it out.

My Code:

#include <pthread.h>
#include <inttypes.h>
#include <stdio.h>
#include <unistd.h>

#ifdef _SC_NPROCESSORS_ONLN
#define NUM_THREADS sysconf(_SC_NPROCESSORS_ONLN)
#else
#define NUM_THREADS 1
#endif

uint64_t numbers[] = {7,3,19,17,199,333}; // Numbers to check

void *work(void *n_void_ptr);
int isPrime(uint64_t n);

int main()
{
    int rc;
    pthread_t thread[NUM_THREADS];

    for (int i = 0; i < sizeof(numbers) / sizeof(uint64_t); i++) {
        rc = pthread_create(&thread[i], NULL, work, &numbers[i]);
    }

    pthread_exit(NULL);

    return 0;
}

void *work(void *n_void_ptr)
{
    uint64_t *n_ptr = (uint64_t *)n_void_ptr;

    if (!isPrime(*n_ptr)) {
        printf("%llu is a prime!\n", *n_ptr);
    }

    pthread_exit(NULL);
}

int isPrime(uint64_t n)
{
    int count = 0;
    uint64_t i; // Any number > n/2 cannot be a factor

    for (i = 2; i < n / 2 - 0.5; i++) {
        if (n % i == 0) {
            count++;
        }

        if (count == 1) {
            printf("%llu is composite!\n", n);

            return -1; // n is not prime
        }
    }

    return 0; // n is prime
}

What you have done is parallelize checking of different numbers. I thought you wanted to split the ranges. — Ajay Brahmakshatriya, Apr 13 '17 at 10:07
My mistake I've changed the above to 51. Ultimately I do want to split the ranges, but am a little lost on how to do so. — Taylor Liesnham, Apr 13 '17 at 10:23
Got your issue, will write an answer. Give me a few minutes. — Ajay Brahmakshatriya, Apr 13 '17 at 10:24

Ajay Brahmakshatriya · Accepted Answer · 2017-04-13T11:21:36.387

So what you want to do is have different threads to check for different non overlapping ranges.

We need a struct first to pass the ranges to the workers. So we start with -

typedef struct {
    int lower;
    int upper;
    int number;
    int result;
} worker_range;

Now in the main I am assuming you need to check 199 and each thread needs to check 50 values.

We start like this

worker_threads **ranges = malloc(sizeof(worker_threads*) * (199 / 50 + 1));

Now we need to spawn the threads

int i;
for ( i = 0; i < 199 / 50 + 1; i++){ //Fix this so that extra threads are not spawned.
    ranges[i] = malloc(sizeof(worker_range));
    ranges[i]->number = 199;
    ranges[i]->lower = 2 + i * 50;
    ranges[i]->upper = range->lower + 50; //We are probably okay with a bit of overflow
    range[i]->result = 0;
    pthread_create(&thread[i], NULL, work, ranges[i]);
}

Now that all threads have started, we wait for them to finish.

int flag = 0;
for ( i = 0 ;i < 199 / 50 + 1; i++) {
    pthread_join(thread[i]);
    if(ranges[i]->result == 1)
        flag = 1;
    free(ranges[i]);
}
if (flag==1){
    printf("%d is composite\n",199);
}else{
    printf("%d is prime\n",199);
}
free(ranges);

Finally the worker function -

void* work(void * param) {
    work_range *range = param;
    int i;
    for(i = range->lower, i < range->upper; i++){
        if (range->number % i == 0){
            (range->result) = 1;
            break;
        }
    }
}

I hope this helps.

You might want to check on the signatures of pthread functions. I wrote from memory and it has been a long time. — Ajay Brahmakshatriya, Apr 13 '17 at 10:54
A suggestion: The only even prime number is 2, so if you handle 2 specially, all the higher ranges only need to check odd numbers, thus halving the work needed. — rossum, Apr 13 '17 at 11:45
@Rossum - For optimization we can check only upto square root of n. But OP specifically asked for *this* algorithm. I agree to your point though. — Ajay Brahmakshatriya, Apr 13 '17 at 11:47

How do I chunk prime numbers for multithreading?

1 Answers1