thread/example/shared_monitor.cpp at develop · boostorg/thread · GitHub

Repository navigation

History

144 lines (132 loc) · 3.29 KB

Raw

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

143

144

// Distributed under the Boost Software License, Version 1.0. (See accompanying

// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <iostream>

#include <boost/thread/mutex.hpp>

#include <boost/thread/shared_mutex.hpp>

#include <boost/thread/lock_algorithms.hpp>

#include <boost/thread/thread_only.hpp>

#if defined BOOST_THREAD_DONT_USE_CHRONO

#include <boost/chrono/chrono_io.hpp>

#endif

#include <cassert>

#include <vector>

#define EXCLUSIVE 1

#define SHARED 2

#define MODE SHARED

class A

{

#if MODE == EXCLUSIVE

typedef boost::mutex mutex_type;

#elif MODE == SHARED

typedef boost::shared_mutex mutex_type;

#else

#error MODE not set

#endif

typedef std::vector<double> C;

mutable mutex_type mut_;

C data_;

public:

A() : data_(10000000) {}

A(const A& a);

A& operator=(const A& a);

void compute(const A& x, const A& y);

};

A::A(const A& a)

{

#if MODE == EXCLUSIVE

boost::unique_lock<mutex_type> lk(a.mut_);

#elif MODE == SHARED

boost::shared_lock<mutex_type> lk(a.mut_);

#else

#error MODE not set

#endif

data_ = a.data_;

}

A::operator=(const A& a)

{

if (this != &a)

{

boost::unique_lock<mutex_type> lk1(mut_, boost::defer_lock);

#if MODE == EXCLUSIVE

boost::unique_lock<mutex_type> lk2(a.mut_, boost::defer_lock);

#elif MODE == SHARED

boost::shared_lock<mutex_type> lk2(a.mut_, boost::defer_lock);

#else

#error MODE not set

#endif

boost::lock(lk1, lk2);

data_ = a.data_;

}

return *this;

}

void

A::compute(const A& x, const A& y)

{

boost::unique_lock<mutex_type> lk1(mut_, boost::defer_lock);

#if MODE == EXCLUSIVE

boost::unique_lock<mutex_type> lk2(x.mut_, boost::defer_lock);

boost::unique_lock<mutex_type> lk3(y.mut_, boost::defer_lock);

#elif MODE == SHARED

boost::shared_lock<mutex_type> lk2(x.mut_, boost::defer_lock);

boost::shared_lock<mutex_type> lk3(y.mut_, boost::defer_lock);

#else

#error MODE not set

#endif

boost::lock(lk1, lk2, lk3);

assert(data_.size() == x.data_.size());

assert(data_.size() == y.data_.size());

for (unsigned i = 0; i < data_.size(); ++i)

data_[i] = (x.data_[i] + y.data_[i]) / 2;

}

A a1;

A a2;

void test_s()

{

A la3 = a1;

for (int i = 0; i < 150; ++i)

{

la3.compute(a1, a2);

}

void test_w()

{

A la3 = a1;

for (int i = 0; i < 10; ++i)

{

la3.compute(a1, a2);

a1 = la3;

a2 = la3;

#if defined BOOST_THREAD_DONT_USE_CHRONO

boost::this_thread::sleep_for(boost::chrono::seconds(1));

#endif

}

int main()

{

#if defined BOOST_THREAD_DONT_USE_CHRONO

typedef boost::chrono::high_resolution_clock Clock;

typedef boost::chrono::duration<double> sec;

Clock::time_point t0 = Clock::now();

#endif

std::vector<boost::thread*> v;

boost::thread thw(test_w);

v.push_back(&thw);

boost::thread thr0(test_w);

v.push_back(&thr0);

boost::thread thr1(test_w);

v.push_back(&thr1);

boost::thread thr2(test_w);

v.push_back(&thr2);

boost::thread thr3(test_w);

v.push_back(&thr3);

for (std::size_t i = 0; i < v.size(); ++i)

v[i]->join();

#if defined BOOST_THREAD_DONT_USE_CHRONO

Clock::time_point t1 = Clock::now();

std::cout << sec(t1-t0) << '\n';

#endif

return 0;

}

thread/example/shared_monitor.cpp at develop · boostorg/thread · GitHub

Repository navigation

Expand file tree

Breadcrumbs

shared_monitor.cpp

Latest commit

History

Breadcrumbs

shared_monitor.cpp

File metadata and controls