ConcurrentPrime/PrimeComputer.cpp at master · NJUShenbin/ConcurrentPrime · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
//
// Created by sbin on 6/13/17.
//

#include <cmath>
#include "PrimeComputer.h"
#include <iostream>
#include <sstream>
#include <omp.h>

bool isPrime(int number){

    if(number<=1){
        return false;
    }

    bool prime = true;

    double sqrtN = sqrt(number);
    for(int i=2; i<=sqrtN; i++) {
        if(number%i==0) {
            prime = false;
            break;
        }
    }

    return prime;
}


vector<int> PrimeComputer::computeSerial(int N) {

    if(N <= 1){
        return vector<int>();
    }

    vector<int> primes;

    for( int i=2; i<=N; i++) {
        if(isPrime(i)) {
            primes.push_back(i);
        }
    }

    return primes;

}

vector<int> PrimeComputer::computeParallel(int N) {

    const int THREAD_NUM = 5;

    if(N <= THREAD_NUM){
        return computeSerial(N);
    }

    thread_handle threads[THREAD_NUM];
    ThreadArg threadArgs[THREAD_NUM];

    for(int i=0;i<THREAD_NUM;i++){

        threadArgs[i].N=N;
        threadArgs[i].threadId=i;
        threadArgs[i].threadNumber=THREAD_NUM;

        createThread(threadArgs[i],threads[i]);
    }

    vector<int> primes;
    for(int i=0;i<THREAD_NUM;i++){
        join(threads[i]);
        primes.insert(primes.end(),threadArgs[i].primes.begin(),threadArgs[i].primes.end());
    }
    return primes;

}

PrimeComputer::return_t PrimeComputer::computePartPrime(void *threadArg) {
    ThreadArg* arg = (ThreadArg*)threadArg;
    for(int i = arg-> threadId ; i<= arg->N ; i += arg->threadNumber){
        if( isPrime(i) ){
            arg->primes.push_back(i);
        }
    }
    return 0;
}

vector<int> PrimeComputer::computeOpenmp(int N) {

    if(N <= 1){
        return vector<int>();
    }

    vector<int> primes;

    int count = 0;
#pragma omp parallel for reduction(+:count)
    for( int i=2; i<=N; i++) {
        if(isPrime(i)) {
            count++;
        }
    }
    cout<<"count:"<<count<<endl;

    return primes;

}