Blowing in the wind

#include <iostream>
#include <mutex>
#include <thread>
#include <vector>
#include <cmath>

std::mutex mtx_;                // mutex for exclusive control
std::vector vec{};         // prime numbers array
int cal_int = 1;                // calc target integer
int max_int = 10000000;         // calc target max number
std::vector threads;       // array of threads
int num_thread = 12;                    // number of threads



void add_prime(int i)           // store the prime numberns in the vector
{
    std::lock_guard lock(mtx_);
    vec.push_back(i);
}

int get_int()                   // get the integer to be tested
{
    std::lock_guard lock(mtx_);
    ++cal_int;
    if (cal_int > 2 && cal_int%2 == 0)      // do not return an even number larger than four
    {
        ++cal_int;
    }
    return cal_int;
}

void ThreadA()
{
    while (true)
    {
        bool flag = false;
        int i = get_int();
        if (i > max_int)
        {
            break;
        }
        int sqt = sqrt(i);
        for (int j = 2; j <= sqt; ++j)
        {
            if (i%j == 0)
            {
                flag = true;
                break;
            }
        }
        if (flag != true)
        {
            add_prime(i);
        }
    }
}

int main()
{
    std::chrono::system_clock::time_point  start, end;
    start = std::chrono::system_clock::now();

    std::cout << std::endl;
    std::cout << "Hardware concurrency = " << std::thread::hardware_concurrency() << std::endl;

    for(size_t i=0; i < num_thread; ++i){
        threads.emplace_back(std::thread(ThreadA));
    }

    for(auto& thread : threads){
        thread.join();
    }

    std::cout << std::endl;
    std::cout << "Number of threads = " << num_thread << std::endl;

    std::cout << std::endl;
    end = std::chrono::system_clock::now();
    double elapsed = std::chrono::duration_cast(end-start).count();
    std::cout << "elapsed time : " << elapsed << " ms" << std::endl;

    std::cout << std::endl;
    std::cout << "number of prime numbers : " << vec.size() << std::endl;

    std::cout << std::endl;
    std::cout << "last five prime numbers" << std::endl;
    std::sort(vec.begin(), vec.end() );
    
    for (auto itr = (vec.end() - 5); itr != vec.end(); ++itr)
    {
        std::cout << *itr << std::endl;
    }

}

Hardware concurrency = 12

Number of threads = 12

elapsed time : 1358 ms

number of prime numbers : 664579

last five prime numbers
9999937
9999943
9999971
9999973
9999991

#include <iostream>
#include <mutex>
#include <thread>
#include <vector>
#include <cmath>

std::mutex mtx_;                // mutex for exclusive control
std::vector vec{};         // prime numbers array
int cal_int = 1;                // calc target integer
int max_int = 10000000;          // calc target max number


void add_prime(int i)
{
    std::lock_guard lock(mtx_);
    vec.push_back(i);
}

int get_int()
{
    std::lock_guard lock(mtx_);
    ++cal_int;
    return cal_int;
}

void ThreadA()
{
    while (true)
    {
        bool flag = false;
        int i = get_int();
        if (i > max_int)
        {
            break;
        }
        int sqt = sqrt(i);
        for (int j = 2; j <= sqt; ++j){
            if (i%j == 0){
                flag = true;
                break;
            }
        }
        if (flag != true){
            add_prime(i);
        }
    }
}

int main()
{
    std::chrono::system_clock::time_point  start, end;
    start = std::chrono::system_clock::now();

    std::cout << std::endl;
    std::cout << "Hardware concurrency = " << std::thread::hardware_concurrency() << std::endl;

    std::thread th_a(ThreadA);
    std::thread th_b(ThreadA);
    std::thread th_c(ThreadA);
    std::thread th_d(ThreadA);

    th_a.join();
    th_b.join();
    th_c.join();
    th_d.join();

    std::cout << std::endl;
    end = std::chrono::system_clock::now();
    double elapsed = std::chrono::duration_cast(end-start).count();
    std::cout << "elapsed time : " << elapsed << " ms" << std::endl;

    std::sort(vec.begin(), vec.end() );
    for (auto itr = (vec.end() - 5); itr != vec.end(); ++itr){
    std::cout << *itr << std::endl;
    }

    return 0;
}

Hardware concurrency = 12

—100000まで計算—

1 thread

elapsed time : 223 ms
999953
999959
999961
999979
999983


2 threads 

elapsed time : 177 ms
999953
999959
999961
999979
999983


3 threads

elapsed time : 184 ms
999953
999959
999961
999979
999983


4 threads

elapsed time : 194 ms
999953
999959
999961
999979
999983


—10000000まで—

1 thread

elapsed time : 4519 ms
9999937
9999943
9999971
9999973
9999991


2 threads

elapsed time : 2646 ms
9999937
9999943
9999971
9999973
9999991


3 threads

elapsed time : 2103 ms
9999937
9999943
9999971
9999973
9999991


4 threads

elapsed time : 1829 ms
9999937
9999943
9999971
9999973
9999991

% make SDKROOT=`xcrun --show-sdk-path` MACOSX_DEPLOYMENT_TARGET=
[ 33%] Building CXX object CMakeFiles/main.dir/main.cpp.o
[ 66%] Building CXX object CMakeFiles/main.dir/header.cpp.o
[100%] Linking CXX executable main
[100%] Built target main

#include <iostream>
#include <chrono>
#include <cmath>
#include <vector>

int main(){

int sqt;
bool flag;
std::vector vec{};

std::chrono::system_clock::time_point  start, end;
start = std::chrono::system_clock::now();

for (int i = 2; i <= 1000000; ++i){         // check prime numbers
    flag = false;
    sqt = sqrt(i);
    for (int j = 2; j <= sqt; ++j){
        if (i%j == 0){
            flag = true;
            break;
        }
    } 
    if (flag != true){
        vec.push_back(i);
    }
}

end = std::chrono::system_clock::now();
double elapsed = std::chrono::duration_cast(end-start).count();
std::cout << "elapsed time : " << elapsed << " ms" << std::endl;

std::cout << std::endl;
std::cout << "number of prime integers(up to 1M) : " << vec.size() << std::endl;
std::cout << std::endl;
std::cout << "last five prime integers " << std::endl;

for (auto itr = (vec.end() - 5); itr != vec.end(); ++itr){
    std::cout << *itr << std::endl;
}
}

import time
import math

start = time.time()
set = list()

flag = False
sqt = 0;
for i in range(2, 1000001):        # check prime numbers
    flag = False;
    sqt = math.sqrt(i)
    for j in range(2, int(sqt) + 1):
        if i%j == 0:
            flag = True
            break
    if flag != True:
        set.append(i)


end = time.time()
print("elapsed time : ",'{:.0f}'.format((end-start)*1000)+ " ms")
print("number of prime integers(up to 1M) : ",len(set))
print("")
print("last five prime integers")
for i in range(5):
    print(set[-5 + i])

c++

elapsed time : 268 ms

number of prime integers(up to 1M) : 78498

last five prime integers 
999953
999959
999961
999979
999983


Python

elapsed time :  9433 ms
number of prime integers(up to 1M) :  78498

last five prime integers
999953
999959
999961
999979
999983