1 /*
2 *
3 * Copyright (c) 2004
4 * John Maddock
5 *
6 * Use, modification and distribution are subject to the
7 * Boost Software License, Version 1.0. (See accompanying file
8 * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
9 *
10 */
11
12 /*
13 * LOCATION: see http://www.boost.org for most recent version.
14 * FILE static_mutex_test.cpp
15 * VERSION see <boost/version.hpp>
16 * DESCRIPTION: test program for boost::static_mutex.
17 */
18
19 #include <boost/regex/pending/static_mutex.hpp>
20 #include <boost/thread/thread.hpp>
21 #include <boost/timer.hpp>
22 #include <iostream>
23 #include <iomanip>
24
25 //
26 // we cannot use the regular Boost.Test in here: it is not thread safe
27 // and calls to BOOST_CHECK will eventually crash on some compilers
28 // (Borland certainly) due to race conditions inside the Boost.Test lib.
29 //
30 #define BOOST_CHECK(pred) if(!(pred)) failed_test(__FILE__, __LINE__, BOOST_STRINGIZE(pred));
31
32 int total_failures = 0;
failed_test(const char * file,int line,const char * pred)33 void failed_test(const char* file, int line, const char* pred)
34 {
35 static boost::static_mutex mut = BOOST_STATIC_MUTEX_INIT ;
36 boost::static_mutex::scoped_lock guard(mut);
37 ++total_failures;
38 std::cout << "Failed test in \"" << file << "\" at line " << line << ": " << pred << std::endl;
39 }
40
print_cycles(int c)41 void print_cycles(int c)
42 {
43 static boost::static_mutex mut = BOOST_STATIC_MUTEX_INIT ;
44 boost::static_mutex::scoped_lock guard(mut);
45 std::cout << "Thread exited after " << c << " cycles." << std::endl;
46 }
47
sufficient_time()48 bool sufficient_time()
49 {
50 // return true if enough time has passed since the tests began:
51 static boost::static_mutex mut = BOOST_STATIC_MUTEX_INIT ;
52 boost::static_mutex::scoped_lock guard(mut);
53 static boost::timer t;
54 // is 10 seconds enough?
55 return t.elapsed() >= 10.0;
56 }
57
58 // define three trivial test proceedures:
t1()59 bool t1()
60 {
61 static boost::static_mutex mut = BOOST_STATIC_MUTEX_INIT ;
62 static int has_lock = 0;
63 static int data = 10000;
64
65 boost::static_mutex::scoped_lock guard(mut);
66 BOOST_CHECK(++has_lock == 1);
67 BOOST_CHECK(guard.locked());
68 BOOST_CHECK(guard);
69 bool result = (--data > 0) ? true : false;
70 BOOST_CHECK(--has_lock == 0);
71 return result;
72 }
73
t2()74 bool t2()
75 {
76 static boost::static_mutex mut = BOOST_STATIC_MUTEX_INIT ;
77 static int has_lock = 0;
78 static int data = 10000;
79
80 boost::static_mutex::scoped_lock guard(mut, false);
81 BOOST_CHECK(0 == guard.locked());
82 BOOST_CHECK(!guard);
83 guard.lock();
84 BOOST_CHECK(++has_lock == 1);
85 BOOST_CHECK(guard.locked());
86 BOOST_CHECK(guard);
87 bool result = (--data > 0) ? true : false;
88 BOOST_CHECK(--has_lock == 0);
89 guard.unlock();
90 BOOST_CHECK(0 == guard.locked());
91 BOOST_CHECK(!guard);
92 return result;
93 }
94
t3()95 bool t3()
96 {
97 static boost::static_mutex mut = BOOST_STATIC_MUTEX_INIT ;
98 static int has_lock = 0;
99 static int data = 10000;
100
101 boost::static_mutex::scoped_lock guard(mut);
102 BOOST_CHECK(++has_lock == 1);
103 BOOST_CHECK(guard.locked());
104 BOOST_CHECK(guard);
105 bool result = (--data > 0) ? true : false;
106 BOOST_CHECK(--has_lock == 0);
107 return result;
108 }
109
110 // define their thread procs:
thread1_proc()111 void thread1_proc()
112 {
113 int cycles = 0;
114 while(!sufficient_time())
115 {
116 t1();
117 t2();
118 ++cycles;
119 }
120 print_cycles(cycles);
121 }
122
thread2_proc()123 void thread2_proc()
124 {
125 int cycles = 0;
126 while(!sufficient_time())
127 {
128 t2();
129 t3();
130 ++cycles;
131 }
132 print_cycles(cycles);
133 }
134
thread3_proc()135 void thread3_proc()
136 {
137 int cycles = 0;
138 while(!sufficient_time())
139 {
140 t1();
141 t3();
142 ++cycles;
143 }
144 print_cycles(cycles);
145 }
146
147 // make sure that at least one of our test proceedures
148 // is called during program startup:
149 struct startup1
150 {
startup1startup1151 startup1()
152 {
153 t1();
154 }
~startup1startup1155 ~startup1()
156 {
157 t1();
158 }
159 };
160
161 startup1 up1;
162
main()163 int main()
164 {
165 (void)up1;
166
167 std::list<boost::shared_ptr<boost::thread> > threads;
168 for(int i = 0; i < 2; ++i)
169 {
170 try{
171 threads.push_back(boost::shared_ptr<boost::thread>(new boost::thread(&thread1_proc)));
172 }
173 catch(const std::exception& e)
174 {
175 std::cerr << "<note>Thread creation failed with message: " << e.what() << "</note>" << std::endl;
176 }
177 }
178 for(int i = 0; i < 2; ++i)
179 {
180 try{
181 threads.push_back(boost::shared_ptr<boost::thread>(new boost::thread(&thread2_proc)));
182 }
183 catch(const std::exception& e)
184 {
185 std::cerr << "<note>Thread creation failed with message: " << e.what() << "</note>" << std::endl;
186 }
187 }
188 for(int i = 0; i < 2; ++i)
189 {
190 try{
191 threads.push_back(boost::shared_ptr<boost::thread>(new boost::thread(&thread3_proc)));
192 }
193 catch(const std::exception& e)
194 {
195 std::cerr << "<note>Thread creation failed with message: " << e.what() << "</note>" << std::endl;
196 }
197 }
198
199 std::list<boost::shared_ptr<boost::thread> >::const_iterator a(threads.begin()), b(threads.end());
200 while(a != b)
201 {
202 (*a)->join();
203 ++a;
204 }
205
206 return total_failures;
207 }
208