cpp_concurrency/Programs/32_ParallelFor/PrimeNumbers.cpp at master · pelocpp/cpp_concurrency · 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
108
109
110
111
112
113
114
// ===========================================================================
// PrimeNumbers.cpp
// ===========================================================================

#include "../30_Threadsafe_Stack/ThreadsafeStack.h"
#include "../30_Threadsafe_Stack/PrimeCalculator.h"

#include "../Logger/Logger.h"
#include "../Logger/ScopedTimer.h"

#include "ParallelFor.h"

constexpr bool Verbose{ false };

namespace Globals
{
    // https://www.michael-holzapfel.de/themen/primzahlen/pz-anzahl.htm

    constexpr size_t NumThreads = 8;

    // constexpr size_t UpperLimit { 100 };             // Found:  25 prime numbers
    // constexpr size_t UpperLimit { 1000 };            // Found:  168 prime numbers
    // constexpr size_t UpperLimit { 100'000 };         // Found:  9.592 prime numbers
    // constexpr size_t UpperLimit { 1'000'000 };       // Found:  78.498 prime numbers
    // constexpr size_t UpperLimit { 10'000'000 };      // Found:  664.579 prime numbers
    constexpr size_t UpperLimit { 100'000'000 };        // Found:  5.761.455 prime numbers
}

// ===========================================================================

Concurrency_ThreadsafeStack::ThreadsafeStack<size_t> g_primes{};

static void calcPrimesRange(size_t start, size_t end)
{
    for (size_t i{ start }; i != end; ++i) {

        if (Concurrency_PrimeCalculator::PrimeCalculator<size_t>::isPrime(i)) {
            g_primes.push(i);
        }
    }
}

static void test_parallel_for_01(size_t from, size_t to, bool useThreads)
{
    using namespace Concurrency_ParallelFor;

    Logger::log(std::cout,
        "Calcalating Prime Numbers from ", from,
        " up to ", to, ':');

    {
        ScopedTimer timer{};

        parallel_for(
            from,
            to,
            [] (size_t start, size_t end) {
                calcPrimesRange(start, end);
            },
            useThreads
        );
    }

    Logger::log(std::cout, "Found: ", g_primes.size(), " prime numbers.");
    Logger::log(std::cout, "Done.");
}

// ===========================================================================

static void test_parallel_for_02(size_t from, size_t to, bool useThreads)
{
    using namespace Concurrency_ThreadsafeStack;
    using namespace Concurrency_PrimeCalculator;
    using namespace Concurrency_ParallelFor;

    Logger::log(std::cout,
        "Calcalating Prime Numbers from ", from,
        " up to ", to, ':');

    ThreadsafeStack<size_t> primes{};

    auto calcPrimesRange = [&] (size_t start, size_t end) {

        PrimeCalculator<size_t> calc{ primes, start, end };
        calc();
    };

    {
        ScopedTimer timer{};

        parallel_for(
            from,
            to,
            [&](size_t start, size_t end) {
                calcPrimesRange(start, end);
            },
            useThreads
        );
    }

    Logger::log(std::cout, "Found: ", primes.size(), " prime numbers.");
    Logger::log(std::cout, "Done.");
}

void test_parallel_for()
{
    test_parallel_for_01(2, Globals::UpperLimit, true);
    test_parallel_for_02(2, Globals::UpperLimit, true);
    //test_parallel_for_02(2, 50, false);
}

// ===========================================================================
// End-of-File
// ===========================================================================