xpcom/tests/TestSynchronization.cpp

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
   2  * vim: sw=4 ts=4 et :
   3  * ***** BEGIN LICENSE BLOCK *****
   4  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version
   7  * 1.1 (the "License"); you may not use this file except in compliance with
   8  * the License. You may obtain a copy of the License at
   9  * http://www.mozilla.org/MPL/
  10  *
  11  * Software distributed under the License is distributed on an "AS IS" basis,
  12  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13  * for the specific language governing rights and limitations under the
  14  * License.
  15  *
  16  * The Original Code is mozilla.org code.
  17  *
  18  * The Initial Developer of the Original Code is
  19  * Netscape Communications Corporation.
  20  * Portions created by the Initial Developer are Copyright (C) 1998
  21  * the Initial Developer. All Rights Reserved.
  22  *
  23  * Contributor(s):
  24  *   Chris Jones <jones.chris.g@gmail.com>
  25  *
  26  * Alternatively, the contents of this file may be used under the terms of
  27  * either of the GNU General Public License Version 2 or later (the "GPL"),
  28  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  29  * in which case the provisions of the GPL or the LGPL are applicable instead
  30  * of those above. If you wish to allow use of your version of this file only
  31  * under the terms of either the GPL or the LGPL, and not to allow others to
  32  * use your version of this file under the terms of the MPL, indicate your
  33  * decision by deleting the provisions above and replace them with the notice
  34  * and other provisions required by the GPL or the LGPL. If you do not delete
  35  * the provisions above, a recipient may use your version of this file under
  36  * the terms of any one of the MPL, the GPL or the LGPL.
  37  *
  38  * ***** END LICENSE BLOCK ***** */
  39
  40 #include "TestHarness.h"
  41
  42 #include "mozilla/CondVar.h"
  43 #include "mozilla/Monitor.h"
  44 #include "mozilla/Mutex.h"
  45 #include "nsAutoLock.h"
  46
  47 using namespace mozilla;
  48
  49 static PRThread*
  50 spawn(void (*run)(void*), void* arg)
  51 {
  52     return PR_CreateThread(PR_SYSTEM_THREAD,
  53                            run,
  54                            arg,
  55                            PR_PRIORITY_NORMAL,
  56                            PR_GLOBAL_THREAD,
  57                            PR_JOINABLE_THREAD,
  58                            0);
  59 }
  60
  61
  62 #define PASS()                                  \
  63     do {                                        \
  64         passed(__FUNCTION__);                   \
  65         return NS_OK;                           \
  66     } while (0)
  67
  68 #define FAIL(why)                               \
  69     do {                                        \
  70         fail("%s | %s - %s", __FILE__, __FUNCTION__, why); \
  71         return NS_ERROR_FAILURE;                \
  72     } while (0)
  73
  74 //-----------------------------------------------------------------------------
  75 // Sanity check: tests that can be done on a single thread
  76 //
  77 static nsresult
  78 Sanity()
  79 {
  80     Mutex lock("sanity::lock");
  81     lock.Lock();
  82     lock.AssertCurrentThreadOwns();
  83     lock.Unlock();
  84
  85     {
  86         MutexAutoLock autolock(lock);
  87         lock.AssertCurrentThreadOwns();
  88     }
  89
  90     lock.Lock();
  91     lock.AssertCurrentThreadOwns();
  92     {
  93         MutexAutoUnlock autounlock(lock);
  94     }
  95     lock.AssertCurrentThreadOwns();
  96     lock.Unlock();
  97
  98     Monitor mon("sanity::monitor");
  99     mon.Enter();
 100     mon.AssertCurrentThreadIn();
 101     mon.Enter();
 102     mon.AssertCurrentThreadIn();
 103     mon.Exit();
 104     mon.AssertCurrentThreadIn();
 105     mon.Exit();
 106
 107     {
 108         MonitorAutoEnter automon(mon);
 109         mon.AssertCurrentThreadIn();
 110     }
 111
 112     PASS();
 113 }
 114
 115 //-----------------------------------------------------------------------------
 116 // Mutex contention tests
 117 //
 118 static Mutex* gLock1;
 119
 120 static void
 121 MutexContention_thread(void* /*arg*/)
 122 {
 123     for (int i = 0; i < 100000; ++i) {
 124         gLock1->Lock();
 125         gLock1->AssertCurrentThreadOwns();
 126         gLock1->Unlock();
 127     }
 128 }
 129
 130 static nsresult
 131 MutexContention()
 132 {
 133     gLock1 = new Mutex("lock1");
 134     // PURPOSELY not checking for OOM.  YAY!
 135
 136     PRThread* t1 = spawn(MutexContention_thread, nsnull);
 137     PRThread* t2 = spawn(MutexContention_thread, nsnull);
 138     PRThread* t3 = spawn(MutexContention_thread, nsnull);
 139
 140     PR_JoinThread(t1);
 141     PR_JoinThread(t2);
 142     PR_JoinThread(t3);
 143
 144     delete gLock1;
 145
 146     PASS();
 147 }
 148
 149 //-----------------------------------------------------------------------------
 150 // Monitor tests
 151 //
 152 static Monitor* gMon1;
 153
 154 static void
 155 MonitorContention_thread(void* /*arg*/)
 156 {
 157     for (int i = 0; i < 100000; ++i) {
 158         gMon1->Enter();
 159         gMon1->AssertCurrentThreadIn();
 160         gMon1->Exit();
 161     }
 162 }
 163
 164 static nsresult
 165 MonitorContention()
 166 {
 167     gMon1 = new Monitor("mon1");
 168
 169     PRThread* t1 = spawn(MonitorContention_thread, nsnull);
 170     PRThread* t2 = spawn(MonitorContention_thread, nsnull);
 171     PRThread* t3 = spawn(MonitorContention_thread, nsnull);
 172
 173     PR_JoinThread(t1);
 174     PR_JoinThread(t2);
 175     PR_JoinThread(t3);
 176
 177     delete gMon1;
 178
 179     PASS();
 180 }
 181
 182
 183 static Monitor* gMon2;
 184
 185 static void
 186 MonitorContention2_thread(void* /*arg*/)
 187 {
 188     for (int i = 0; i < 100000; ++i) {
 189         gMon2->Enter();
 190         gMon2->AssertCurrentThreadIn();
 191         {
 192             gMon2->Enter();
 193             gMon2->AssertCurrentThreadIn();
 194             gMon2->Exit();
 195         }
 196         gMon2->AssertCurrentThreadIn();
 197         gMon2->Exit();
 198     }
 199 }
 200
 201 static nsresult
 202 MonitorContention2()
 203 {
 204     gMon2 = new Monitor("mon1");
 205
 206     PRThread* t1 = spawn(MonitorContention2_thread, nsnull);
 207     PRThread* t2 = spawn(MonitorContention2_thread, nsnull);
 208     PRThread* t3 = spawn(MonitorContention2_thread, nsnull);
 209
 210     PR_JoinThread(t1);
 211     PR_JoinThread(t2);
 212     PR_JoinThread(t3);
 213
 214     delete gMon2;
 215
 216     PASS();
 217 }
 218
 219
 220 static Monitor* gMon3;
 221 static PRInt32 gMonFirst;
 222
 223 static void
 224 MonitorSyncSanity_thread(void* /*arg*/)
 225 {
 226     gMon3->Enter();
 227     gMon3->AssertCurrentThreadIn();
 228     if (gMonFirst) {
 229         gMonFirst = 0;
 230         gMon3->Wait();
 231         gMon3->Enter();
 232     } else {
 233         gMon3->Notify();
 234         gMon3->Enter();
 235     }
 236     gMon3->AssertCurrentThreadIn();
 237     gMon3->Exit();
 238     gMon3->AssertCurrentThreadIn();
 239     gMon3->Exit();
 240 }
 241
 242 static nsresult
 243 MonitorSyncSanity()
 244 {
 245     gMon3 = new Monitor("monitor::syncsanity");
 246
 247     for (PRInt32 i = 0; i < 10000; ++i) {
 248         gMonFirst = 1;
 249         PRThread* ping = spawn(MonitorSyncSanity_thread, nsnull);
 250         PRThread* pong = spawn(MonitorSyncSanity_thread, nsnull);
 251         PR_JoinThread(ping);
 252         PR_JoinThread(pong);
 253     }
 254
 255     delete gMon3;
 256
 257     PASS();
 258 }
 259
 260 //-----------------------------------------------------------------------------
 261 // Condvar tests
 262 //
 263 static Mutex* gCvlock1;
 264 static CondVar* gCv1;
 265 static PRInt32 gCvFirst;
 266
 267 static void
 268 CondVarSanity_thread(void* /*arg*/)
 269 {
 270     gCvlock1->Lock();
 271     gCvlock1->AssertCurrentThreadOwns();
 272     if (gCvFirst) {
 273         gCvFirst = 0;
 274         gCv1->Wait();
 275     } else {
 276         gCv1->Notify();
 277     }
 278     gCvlock1->AssertCurrentThreadOwns();
 279     gCvlock1->Unlock();
 280 }
 281
 282 static nsresult
 283 CondVarSanity()
 284 {
 285     gCvlock1 = new Mutex("cvlock1");
 286     gCv1 = new CondVar(*gCvlock1, "cvlock1");
 287
 288     for (PRInt32 i = 0; i < 10000; ++i) {
 289         gCvFirst = 1;
 290         PRThread* ping = spawn(CondVarSanity_thread, nsnull);
 291         PRThread* pong = spawn(CondVarSanity_thread, nsnull);
 292         PR_JoinThread(ping);
 293         PR_JoinThread(pong);
 294     }
 295
 296     delete gCv1;
 297     delete gCvlock1;
 298
 299     PASS();
 300 }
 301
 302 //-----------------------------------------------------------------------------
 303 // AutoLock tests
 304 //
 305 static nsresult
 306 AutoLock()
 307 {
 308     Mutex l1("autolock");
 309     MutexAutoLock autol1(l1);
 310
 311     l1.AssertCurrentThreadOwns();
 312
 313     {
 314         Mutex l2("autolock2");
 315         MutexAutoLock autol2(l2);
 316
 317         l1.AssertCurrentThreadOwns();
 318         l2.AssertCurrentThreadOwns();
 319     }
 320
 321     l1.AssertCurrentThreadOwns();
 322
 323     PASS();
 324 }
 325
 326 //-----------------------------------------------------------------------------
 327 // AutoUnlock tests
 328 //
 329 static nsresult
 330 AutoUnlock()
 331 {
 332     Mutex l1("autounlock");
 333     Mutex l2("autounlock2");
 334
 335     l1.Lock();
 336     l1.AssertCurrentThreadOwns();
 337
 338     {
 339         MutexAutoUnlock autol1(l1);
 340         {
 341             l2.Lock();
 342             l2.AssertCurrentThreadOwns();
 343
 344             MutexAutoUnlock autol2(l2);
 345         }
 346         l2.AssertCurrentThreadOwns();
 347         l2.Unlock();
 348     }
 349     l1.AssertCurrentThreadOwns();
 350
 351     l1.Unlock();
 352
 353     PASS();
 354 }
 355
 356 //-----------------------------------------------------------------------------
 357 // AutoMonitor tests
 358 //
 359 static nsresult
 360 AutoMonitor()
 361 {
 362     Monitor m1("automonitor");
 363     Monitor m2("automonitor2");
 364
 365     m1.Enter();
 366     m1.AssertCurrentThreadIn();
 367     {
 368         MonitorAutoEnter autom1(m1);
 369         m1.AssertCurrentThreadIn();
 370
 371         m2.Enter();
 372         m2.AssertCurrentThreadIn();
 373         {
 374             MonitorAutoEnter autom2(m2);
 375             m1.AssertCurrentThreadIn();
 376             m2.AssertCurrentThreadIn();
 377         }
 378         m2.AssertCurrentThreadIn();
 379         m2.Exit();
 380
 381         m1.AssertCurrentThreadIn();
 382     }
 383     m1.AssertCurrentThreadIn();
 384     m1.Exit();
 385
 386     PASS();
 387 }
 388
 389 //-----------------------------------------------------------------------------
 390
 391 int
 392 main(int argc, char** argv)
 393 {
 394     ScopedXPCOM xpcom("Synchronization (" __FILE__ ")");
 395     if (xpcom.failed())
 396         return 1;
 397
 398     int rv = 0;
 399
 400     if (NS_FAILED(Sanity()))
 401         rv = 1;
 402     if (NS_FAILED(MutexContention()))
 403         rv = 1;
 404     if (NS_FAILED(MonitorContention()))
 405         rv = 1;
 406     if (NS_FAILED(MonitorContention2()))
 407         rv = 1;
 408     if (NS_FAILED(MonitorSyncSanity()))
 409         rv = 1;
 410     if (NS_FAILED(CondVarSanity()))
 411         rv = 1;
 412     if (NS_FAILED(AutoLock()))
 413         rv = 1;
 414     if (NS_FAILED(AutoUnlock()))
 415         rv = 1;
 416     if (NS_FAILED(AutoMonitor()))
 417         rv = 1;
 418
 419     return rv;
 420 }