cpp_concurrency/Programs/20_StrategizedLocking/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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
// ===========================================================================
// PrimeNumbers.cpp
// ===========================================================================

#include "../Globals/GlobalPrimes.h"

#include "PrimeCalculator.h"
#include "ThreadsafeStack.h"

#include "StrategizedLock.h"

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

#include <cstddef>
#include <iostream>
#include <optional>
#include <vector>

#ifdef _DEBUG
static constexpr std::size_t MaxIterations = 10'000'000;     // debug
#else
static constexpr std::size_t MaxIterations = 10'000'000;     // release
#endif

void test_strategized_locking_01()
{
    using namespace Concurrency_ThreadsafeStack;
    using namespace Concurrency_StrategizedLock;

    NoLock lock;
    // ExclusiveLock lock;

    ThreadsafeStack<std::size_t> stack{ lock };

    Logger::log(std::cout, "Calling push ", MaxIterations, " times:");

    ScopedTimer watch{};

    for (std::size_t i = 0; i != MaxIterations; ++i) {
        stack.push(i);

        std::size_t value{};
        stack.pop(value);
    }
}

void test_strategized_locking_02()
{
    using namespace Concurrency_ThreadsafeStack;
    using namespace Concurrency_StrategizedLock;

    Logger::log(std::cout, "Testing RecursiveLock");

    // ExclusiveLock lock;      // crashes // need to modify pop method, calling size or empty method
    RecursiveLock lock;         // works

    ThreadsafeStack<std::size_t> stack{ lock };

    // just want to test recursive lock
    stack.push(123);
    std::size_t value{};
    stack.pop(value);

    Logger::log(std::cout, "Done.");
}

void test_strategized_locking_03()
{
    using namespace Concurrency_ThreadsafeStack;
    using namespace Concurrency_PrimeCalculator;
    using namespace Concurrency_StrategizedLock;

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

    // compare these two Lock objects // which one should be used in this example
    NoLock lock;
    // ExclusiveLock lock;

    ThreadsafeStack<std::size_t> primes{ lock };

    PrimeCalculator<std::size_t> calc{ primes, PrimeNumberLimits::LowerLimit, PrimeNumberLimits::UpperLimit + 1 };

    ScopedTimer watch{};

    std::thread calculator{ calc };
    calculator.join();

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

void test_strategized_locking_04()
{
    using namespace Concurrency_ThreadsafeStack;
    using namespace Concurrency_PrimeCalculator;
    using namespace Concurrency_StrategizedLock;

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

    // NoLock lock;   // crashes sporadically // Access Violation // 0xc0000005
    ExclusiveLock lock;

    ThreadsafeStack<std::size_t> primes{ lock };

    unsigned int NumThreads = std::thread::hardware_concurrency();
    Logger::log(std::cout, "Number of concurrent threads currently supported: ", NumThreads, ':');

    std::vector<std::thread> threads;
    threads.reserve(NumThreads);

    std::size_t range = (PrimeNumberLimits::UpperLimit - PrimeNumberLimits::LowerLimit) / NumThreads;
    std::size_t start = PrimeNumberLimits::LowerLimit;
    std::size_t end = start + range;

    ScopedTimer watch{};

    // setup threads
    for (std::size_t i{}; i != NumThreads - 1; ++i) {

        PrimeCalculator<std::size_t> calc{ primes, start, end };
        threads.emplace_back(calc);

        start = end;
        end = start + range;
    }

    // setup last thread
    end = PrimeNumberLimits::UpperLimit;
    PrimeCalculator<std::size_t> calc{ primes, start, end + 1 };
    threads.emplace_back(calc);

    // wait for end of all threads
    for (std::size_t i{}; i != NumThreads; ++i) {
        threads[i].join();
    }

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

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