Mercurial > projects > ldc

comparison tango/example/synchronization/mutex.d @ 132:1700239cab2e trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[svn r136] MAJOR UNSTABLE UPDATE!!! Initial commit after moving to Tango instead of Phobos. Lots of bugfixes... This build is not suitable for most things.
author lindquist
date Fri, 11 Jan 2008 17:57:40 +0100
parents
children
comparison
equal deleted inserted replaced
131:5825d48b27d1 132:1700239cab2e
1 /*******************************************************************************
2 copyright: Copyright (c) 2006 Juan Jose Comellas. All rights reserved
3 license: BSD style: $(LICENSE)
4 author: Juan Jose Comellas <juanjo@comellas.com.ar>
5 Converted to use core.sync by Sean Kelly <sean@f4.ca>
6 *******************************************************************************/
7
8 private import tango.core.sync.Mutex;
9 private import tango.core.Exception;
10 private import tango.core.Thread;
11 private import tango.io.Stdout;
12 private import tango.text.convert.Integer;
13 debug (mutex)
14 {
15 private import tango.util.log.Log;
16 private import tango.util.log.ConsoleAppender;
17 private import tango.util.log.DateLayout;
18 }
19
20
21 /**
22 * Example program for the tango.core.sync.Mutex module.
23 */
24 void main(char[][] args)
25 {
26 debug (mutex)
27 {
28 Logger log = Log.getLogger("mutex");
29
30 log.addAppender(new ConsoleAppender(new DateLayout()));
31
32 log.info("Mutex test");
33 }
34
35 testNonRecursive();
36 testLocking();
37 testRecursive();
38 }
39
40 /**
41 * Test that non-recursive mutexes actually do what they're supposed to do.
42 *
43 * Remarks:
44 * Windows only supports recursive mutexes.
45 */
46 void testNonRecursive()
47 {
48 version (Posix)
49 {
50 debug (mutex)
51 {
52 Logger log = Log.getLogger("mutex.non-recursive");
53 }
54
55 Mutex mutex = new Mutex(Mutex.Type.NonRecursive);
56 bool couldLock;
57
58 try
59 {
60 mutex.lock();
61 debug (mutex)
62 log.trace("Acquired mutex");
63 couldLock = mutex.tryLock();
64 if (couldLock)
65 {
66 debug (mutex)
67 {
68 log.trace("Re-acquired mutex");
69 log.trace("Releasing mutex");
70 }
71 mutex.unlock();
72 }
73 else
74 {
75 debug (mutex)
76 log.trace("Re-acquiring the mutex failed");
77 }
78 debug (mutex)
79 log.trace("Releasing mutex");
80 mutex.unlock();
81 }
82 catch (SyncException e)
83 {
84 Stderr.formatln("Sync exception caught when testing non-recursive mutexes:\n{0}\n", e.toString());
85 }
86 catch (Exception e)
87 {
88 Stderr.formatln("Unexpected exception caught when testing non-recursive mutexes:\n{0}\n", e.toString());
89 }
90
91 if (!couldLock)
92 {
93 debug (mutex)
94 log.info("The non-recursive Mutex test was successful");
95 }
96 else
97 {
98 debug (mutex)
99 {
100 log.error("Non-recursive mutexes are not working: "
101 "Mutex.tryAcquire() did not fail on an already acquired mutex");
102 assert(false);
103 }
104 else
105 {
106 assert(false, "Non-recursive mutexes are not working: "
107 "Mutex.tryAcquire() did not fail on an already acquired mutex");
108 }
109 }
110 }
111 }
112
113 /**
114 * Create several threads that acquire and release a mutex several times.
115 */
116 void testLocking()
117 {
118 const uint MaxThreadCount = 10;
119 const uint LoopsPerThread = 1000;
120
121 debug (mutex)
122 {
123 Logger log = Log.getLogger("mutex.locking");
124 }
125
126 Mutex mutex = new Mutex();
127 uint lockCount = 0;
128
129 void mutexLockingThread()
130 {
131 try
132 {
133 for (uint i; i < LoopsPerThread; i++)
134 {
135 synchronized (mutex)
136 {
137 lockCount++;
138 }
139 }
140 }
141 catch (SyncException e)
142 {
143 Stderr.formatln("Sync exception caught inside mutex testing thread:\n{0}\n", e.toString());
144 }
145 catch (Exception e)
146 {
147 Stderr.formatln("Unexpected exception caught inside mutex testing thread:\n{0}\n", e.toString());
148 }
149 }
150
151 ThreadGroup group = new ThreadGroup();
152 Thread thread;
153 char[10] tmp;
154
155 for (uint i = 0; i < MaxThreadCount; i++)
156 {
157 thread = new Thread(&mutexLockingThread);
158 thread.name = "thread-" ~ format(tmp, i);
159
160 debug (mutex)
161 log.trace("Created thread " ~ thread.name);
162 thread.start();
163
164 group.add(thread);
165 }
166
167 debug (mutex)
168 log.trace("Waiting for threads to finish");
169 group.joinAll();
170
171 if (lockCount == MaxThreadCount * LoopsPerThread)
172 {
173 debug (mutex)
174 log.info("The Mutex locking test was successful");
175 }
176 else
177 {
178 debug (mutex)
179 {
180 log.error("Mutex locking is not working properly: "
181 "the number of times the mutex was acquired is incorrect");
182 assert(false);
183 }
184 else
185 {
186 assert(false,"Mutex locking is not working properly: "
187 "the number of times the mutex was acquired is incorrect");
188 }
189 }
190 }
191
192 /**
193 * Test that recursive mutexes actually do what they're supposed to do.
194 */
195 void testRecursive()
196 {
197 const uint LoopsPerThread = 1000;
198
199 debug (mutex)
200 {
201 Logger log = Log.getLogger("mutex.recursive");
202 }
203
204 Mutex mutex = new Mutex;
205 uint lockCount = 0;
206
207 try
208 {
209 for (uint i = 0; i < LoopsPerThread; i++)
210 {
211 mutex.lock();
212 lockCount++;
213 }
214 }
215 catch (SyncException e)
216 {
217 Stderr.formatln("Sync exception caught in recursive mutex test:\n{0}\n", e.toString());
218 }
219 catch (Exception e)
220 {
221 Stderr.formatln("Unexpected exception caught in recursive mutex test:\n{0}\n", e.toString());
222 }
223
224 for (uint i = 0; i < lockCount; i++)
225 {
226 mutex.unlock();
227 }
228
229 if (lockCount == LoopsPerThread)
230 {
231 debug (mutex)
232 log.info("The recursive Mutex test was successful");
233 }
234 else
235 {
236 debug (mutex)
237 {
238 log.error("Recursive mutexes are not working: "
239 "the number of times the mutex was acquired is incorrect");
240 assert(false);
241 }
242 else
243 {
244 assert(false, "Recursive mutexes are not working: "
245 "the number of times the mutex was acquired is incorrect");
246 }
247 }
248 }