You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
110 lines
2.3 KiB
110 lines
2.3 KiB
// This file is under GNU General Public License 3.0
|
|
// see LICENSE.txt
|
|
|
|
#include <iostream>
|
|
#include <thread>
|
|
#include <cassert>
|
|
#include <pEp/std_utils.hh>
|
|
#include "../src/CountingSemaphore.hh"
|
|
|
|
using namespace std;
|
|
using namespace pEp;
|
|
|
|
thread make_two_threads_for_many_threads()
|
|
{
|
|
thread res([&]() {
|
|
CountingSemaphore semaphore;
|
|
semaphore = 3;
|
|
|
|
thread thread1([&]() {
|
|
semaphore.p ();
|
|
semaphore.p ();
|
|
semaphore.p ();
|
|
// Now the count is at 0, assuming the other thread has not
|
|
// started yet; otherwise it should be at 1.
|
|
|
|
semaphore.p ();
|
|
//cout << "1: done\n";
|
|
});
|
|
|
|
Utils::sleep_millis(1000);
|
|
|
|
thread thread2([&]() {
|
|
semaphore.v();
|
|
});
|
|
|
|
thread1.join();
|
|
thread2.join();
|
|
|
|
assert (semaphore.load() == 0);
|
|
});
|
|
return res;
|
|
}
|
|
|
|
void many_threads()
|
|
{
|
|
int i;
|
|
|
|
#define N 1000
|
|
thread threads[N];
|
|
std::cout << "starting " << N
|
|
<< " threads, each starting and joining a thread pair...\n";
|
|
for (i = 0; i < N; i ++)
|
|
threads [i] = make_two_threads_for_many_threads ();
|
|
std::cout << "joining threads...\n";
|
|
for (i = 0; i < N; i ++)
|
|
threads [i].join();
|
|
#undef N
|
|
std::cout << "many_threads done.\n\n";
|
|
}
|
|
|
|
void v_times (CountingSemaphore &semaphore,
|
|
int times)
|
|
{
|
|
std::cout << "V'ing " << times << " times...\n";
|
|
for (int i = 0; i < times; i ++)
|
|
semaphore.v ();
|
|
std::cout << "... I V'd " << times << " times.\n";
|
|
}
|
|
|
|
void p_times (CountingSemaphore &semaphore,
|
|
int times)
|
|
{
|
|
std::cout << "P'ing " << times << " times...\n";
|
|
for (int i = 0; i < times; i ++)
|
|
semaphore.p ();
|
|
std::cout << "... I P'd " << times << " times.\n";
|
|
}
|
|
|
|
void few_threads()
|
|
{
|
|
#define HALF_N (1000 * 1000 * 10)
|
|
#define N (HALF_N * 2)
|
|
CountingSemaphore semaphore;
|
|
|
|
thread thread_p1([&]() {
|
|
p_times (semaphore, HALF_N);
|
|
});
|
|
thread thread_v([&]() {
|
|
v_times (semaphore, N);
|
|
});
|
|
thread thread_p2([&]() {
|
|
p_times (semaphore, HALF_N);
|
|
});
|
|
#undef HALF_N
|
|
#undef N
|
|
thread_v.join();
|
|
thread_p1.join();
|
|
thread_p2.join();
|
|
|
|
assert (semaphore.load() == 0);
|
|
|
|
std::cout << "few_thrads done.\n\n";
|
|
}
|
|
|
|
int main()
|
|
{
|
|
many_threads ();
|
|
few_threads ();
|
|
return 0;
|
|
}
|