bgirgis/concurrency-in-action
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Run clang-format

Browse Source
This commit is contained in:
Bassem Girgis
2018-10-18 00:40:34 -05:00
parent fffe4528da
commit 31c32e368a
149 changed files with 5974 additions and 6287 deletions
Download Patch File Download Diff File Expand all files Collapse all files

171
ch4/queue.cpp
View File

@@ -1,104 +1,105 @@
#include <iostream>
#include <condition_variable>
#include <cstdio>
#include <queue>
#include <thread>
#include <iostream>
#include <memory>
#include <mutex>
#include <condition_variable>
#include <queue>
#include <thread>
template <typename T>
class queue
{
private:
mutable std::mutex mut;
std::queue<T> data_queue;
std::condition_variable data_cond;
class queue {
private:
mutable std::mutex mut;
std::queue<T> data_queue;
std::condition_variable data_cond;
public:
queue(){}
public:
queue() {}
queue(const queue& other)
{
std::lock_guard<std::mutex> lk(other.mut);
data_queue = other.data_queue;
queue(const queue& other)
{
std::lock_guard<std::mutex> lk(other.mut);
data_queue = other.data_queue;
}
void push(T new_value)
{
std::lock_guard<std::mutex> lk(mut);
data_queue.push(new_value);
data_cond.notify_one();
}
void wait_and_pop(T& value)
{
std::unique_lock<std::mutex> lk(mut);
data_cond.wait(lk, [this] { return !data_queue.empty(); });
value = data_queue.front();
data_queue.pop();
}
std::shared_ptr<T> wait_and_pop()
{
std::unique_lock<std::mutex> lk(mut);
data_cond.wait(lk, [this] { return !data_queue.empty(); });
std::shared_ptr<T> res(std::make_shared<T>(data_queue.front()));
data_queue.pop();
return res;
}
bool try_pop(T& value)
{
std::lock_guard<std::mutex> lk(mut);
if (data_queue.empty()) {
return false;
}
value = data_queue.front();
data_queue.pop();
return true;
}
void push(T new_value)
{
std::lock_guard<std::mutex> lk(mut);
data_queue.push(new_value);
data_cond.notify_one();
std::shared_ptr<T> try_pop()
{
std::lock_guard<std::mutex> lk(mut);
if (data_queue.empty()) {
return std::shared_ptr<T>();
}
std::shared_ptr<T> res(std::make_shared<T>(data_queue.front()));
data_queue.pop();
return res;
}
void wait_and_pop(T& value)
{
std::unique_lock<std::mutex> lk(mut);
data_cond.wait(lk, [this]{return !data_queue.empty();});
value = data_queue.front();
data_queue.pop();
}
std::shared_ptr<T> wait_and_pop()
{
std::unique_lock<std::mutex> lk(mut);
data_cond.wait(lk, [this]{return !data_queue.empty();});
std::shared_ptr<T> res(std::make_shared<T>(data_queue.front()));
data_queue.pop();
return res;
}
bool try_pop(T& value)
{
std::lock_guard<std::mutex> lk(mut);
if (data_queue.empty()) {
return false;
}
value = data_queue.front();
data_queue.pop();
return true;
}
std::shared_ptr<T> try_pop()
{
std::lock_guard<std::mutex> lk(mut);
if (data_queue.empty()) {
return std::shared_ptr<T>();
}
std::shared_ptr<T> res(std::make_shared<T>(data_queue.front()));
data_queue.pop();
return res;
}
bool empty() const
{
std::lock_guard<std::mutex> lk(mut);
return data_queue.empty();
}
bool empty() const
{
std::lock_guard<std::mutex> lk(mut);
return data_queue.empty();
}
};
void push(queue<int>* q)
void
push(queue<int>* q)
{
for (int i = 0; i < 10; ++i) {
//std::cout << "pushing " << i << std::endl;
printf("pushing %d\n", i);
q->push(i);
}
for (int i = 0; i < 10; ++i) {
// std::cout << "pushing " << i << std::endl;
printf("pushing %d\n", i);
q->push(i);
}
}
void pop(queue<int>* q)
void
pop(queue<int>* q)
{
for (int i = 0; i < 10; ++i) {
printf("poping %d\n", *q->wait_and_pop());
}
}
int main()
{
queue<int> q;
std::thread t1(push,&q);
std::thread t2(pop,&q);
t1.join();
t2.join();
return 0;
for (int i = 0; i < 10; ++i) {
printf("poping %d\n", *q->wait_and_pop());
}
}
int
main()
{
queue<int> q;
std::thread t1(push, &q);
std::thread t2(pop, &q);
t1.join();
t2.join();
return 0;
}

116
ch4/quicksort.cpp
View File

@@ -1,74 +1,70 @@
#include <iostream>
#include <cstdio>
#include <list>
#include <thread>
#include <memory>
#include <algorithm>
#include <cstdio>
#include <future>
#include <iostream>
#include <list>
#include <memory>
#include <thread>
std::ostream& operator<<(std::ostream& ostr, const std::list<int>& list)
std::ostream&
operator<<(std::ostream& ostr, const std::list<int>& list)
{
for (auto &i : list) {
ostr << " " << i;
}
return ostr;
for (auto& i : list) {
ostr << " " << i;
}
return ostr;
}
template<typename T>
std::list<T> sequential_quick_sort(std::list<T> input)
template <typename T>
std::list<T>
sequential_quick_sort(std::list<T> input)
{
if(input.empty())
{
return input;
}
std::list<T> result;
result.splice(result.begin(),input,input.begin());
T const& pivot=*result.begin();
auto divide_point=std::partition(input.begin(),input.end(),
[&](T const& t){return t<pivot;});
std::list<T> lower_part;
lower_part.splice(lower_part.end(),input,input.begin(),
divide_point);
auto new_lower(
sequential_quick_sort(std::move(lower_part)));
auto new_higher(
sequential_quick_sort(std::move(input)));
result.splice(result.end(),new_higher);
result.splice(result.begin(),new_lower);
return result;
if (input.empty()) {
return input;
}
std::list<T> result;
result.splice(result.begin(), input, input.begin());
T const& pivot = *result.begin();
auto divide_point = std::partition(
input.begin(), input.end(), [&](T const& t) { return t < pivot; });
std::list<T> lower_part;
lower_part.splice(lower_part.end(), input, input.begin(), divide_point);
auto new_lower(sequential_quick_sort(std::move(lower_part)));
auto new_higher(sequential_quick_sort(std::move(input)));
result.splice(result.end(), new_higher);
result.splice(result.begin(), new_lower);
return result;
}
template<typename T>
std::list<T> parallel_quick_sort(std::list<T> input)
template <typename T>
std::list<T>
parallel_quick_sort(std::list<T> input)
{
if(input.empty())
{
return input;
}
std::list<T> result;
result.splice(result.begin(),input,input.begin());
T const& pivot=*result.begin();
auto divide_point=std::partition(input.begin(),input.end(),
[&](T const& t){return t<pivot;});
std::list<T> lower_part;
lower_part.splice(lower_part.end(),input,input.begin(),
divide_point);
std::future<std::list<T> > new_lower(
std::async(&parallel_quick_sort<T>,std::move(lower_part)));
auto new_higher(
parallel_quick_sort(std::move(input)));
result.splice(result.end(),new_higher);
result.splice(result.begin(),new_lower.get());
return result;
if (input.empty()) {
return input;
}
std::list<T> result;
result.splice(result.begin(), input, input.begin());
T const& pivot = *result.begin();
auto divide_point = std::partition(
input.begin(), input.end(), [&](T const& t) { return t < pivot; });
std::list<T> lower_part;
lower_part.splice(lower_part.end(), input, input.begin(), divide_point);
std::future<std::list<T>> new_lower(
std::async(&parallel_quick_sort<T>, std::move(lower_part)));
auto new_higher(parallel_quick_sort(std::move(input)));
result.splice(result.end(), new_higher);
result.splice(result.begin(), new_lower.get());
return result;
}
int main()
int
main()
{
std::list<int> list1 = {4, 2, 1, 5, 8, 9, 7};
std::list<int> sorted1 = sequential_quick_sort(list1);
std::list<int> sorted2 = parallel_quick_sort(list1);
std::cout << "sorted1: " << sorted1 << std::endl;
std::cout << "sorted2: " << sorted2 << std::endl;
return 0;
std::list<int> list1 = {4, 2, 1, 5, 8, 9, 7};
std::list<int> sorted1 = sequential_quick_sort(list1);
std::list<int> sorted2 = parallel_quick_sort(list1);
std::cout << "sorted1: " << sorted1 << std::endl;
std::cout << "sorted2: " << sorted2 << std::endl;
return 0;
}