samples/ThreadSafe/main.cxx

   1 /*
   2  * main.cxx
   3  *
   4  * PWLib application source file for ThreadSafe
   5  *
   6  * Main program entry point.
   7  *
   8  * Copyright 2002 Equivalence
   9  *
  10  * $Log$
  11  * Revision 1.6  2004/04/04 13:24:19  rjongbloed
  12  * Changes to support native C++ Run Time Type Information
  13  *
  14  * Revision 1.5  2003/10/27 22:12:56  dereksmithies
  15  * Add more good changes to get Compare method work. Thanks to Gene Small
  16  *
  17  * Revision 1.4  2003/10/13 23:38:31  dereksmithies
  18  * Add debugging statements, usage(), Fixed Compare method. Thanks Gene Small.
  19  *
  20  * Revision 1.3  2002/12/11 03:38:45  robertj
  21  * Added more tests
  22  *
  23  * Revision 1.2  2002/05/02 00:30:26  robertj
  24  * Added dump of thread times during start up.
  25  *
  26  * Revision 1.1  2002/05/01 04:16:44  robertj
  27  * Added thread safe collection classes.
  28  *
  29  */
  30
  31 #include <ptlib.h>
  32 #include "main.h"
  33
  34 #include <ptclib/random.h>
  35
  36
  37 PCREATE_PROCESS(ThreadSafe);
  38
  39
  40 ///////////////////////////////////////////////////////////////////////////////
  41
  42 TestObject::TestObject(ThreadSafe & proc, unsigned val)
  43   : process(proc)
  44 {
  45   value = val;
  46
  47   process.mutexObjects.Wait();
  48   process.totalObjects++;
  49   process.currentObjects++;
  50   process.mutexObjects.Signal();
  51 }
  52
  53
  54 TestObject::~TestObject()
  55 {
  56   process.mutexObjects.Wait();
  57   process.currentObjects--;
  58   process.mutexObjects.Signal();
  59 }
  60
  61
  62 PObject::Comparison TestObject::Compare(const PObject & obj) const
  63 {
  64   PAssert(PIsDescendant(&obj, TestObject), PInvalidCast);
  65   unsigned othervalue = ((const TestObject &)obj).value;
  66
  67   if (value < othervalue)
  68     return LessThan;
  69   if (value > othervalue)
  70     return GreaterThan;
  71   return EqualTo;
  72 }
  73
  74
  75 void TestObject::PrintOn(ostream & strm) const
  76 {
  77   strm << value;
  78 }
  79
  80
  81 ///////////////////////////////////////////////////////////////////////////////
  82
  83 ThreadSafe::ThreadSafe()
  84   : PProcess("Equivalence", "ThreadSafe", 1, 0, AlphaCode, 1)
  85 {
  86   threadCount = 0;
  87   totalObjects = 0;
  88   currentObjects = 0;
  89 }
  90
  91
  92 ThreadSafe::~ThreadSafe()
  93 {
  94   unsorted.RemoveAll();
  95   sorted.RemoveAll();
  96   sparse.RemoveAll();
  97 }
  98
  99 void ThreadSafe::Usage()
 100 {
 101   cout << "Usage: threadsafe {options} [number]" << endl
 102        << "-t (more t's for more detail) logging on" << endl
 103        << "-o output file for logging" << endl
 104        << "-1 (or --test1) carry out test 1" << endl
 105        << "-2 (or --test2) carry out test 2" << endl
 106        << "-3 (or --test3) carry out test 3" << endl
 107        << "The number field is optional, and specifies the number of threads for test 1" << endl
 108        << endl;
 109   return;
 110 }
 111
 112
 113
 114 void ThreadSafe::Main()
 115 {
 116   PArgList & args = GetArguments();
 117
 118   args.Parse(
 119              "t-trace."       "-no-trace."
 120              "o-output:"      "-no-output."
 121              "1-test1."       "-no-test1."
 122              "2-test2."       "-no-test2."
 123              "3-test3."       "-no-test3.");
 124
 125   PTrace::Initialise(args.GetOptionCount('t'),
 126                      args.HasOption('o') ? (const char *)args.GetOptionString('o') : NULL,
 127                      PTrace::Blocks | PTrace::Timestamp | PTrace::Thread | PTrace::FileAndLine);
 128
 129   if (args.HasOption('1'))
 130     Test1(args);
 131   else if (args.HasOption('2'))
 132     Test2(args);
 133   else if (args.HasOption('3'))
 134     Test3(args);
 135   else Usage();
 136
 137   PTrace::ClearOptions(0);
 138   PTrace::SetLevel(0);
 139 }
 140
 141
 142 void ThreadSafe::Test1(PArgList & args)
 143 {
 144   if (args.GetCount() > 0)
 145     threadCount = args[0].AsUnsigned();
 146   else
 147     threadCount = 99;
 148
 149   cout << "Starting " << threadCount << " threads." << endl;
 150
 151   for (PINDEX i = 0; i < threadCount; i++) {
 152     PTimeInterval duration = PRandom::Number()%540000 + 60000;
 153     cout << setw(4) << (i + 1) << '=' << duration;
 154     if (i%5 == 4)
 155       cout << '\n';
 156     PThread::Create(PCREATE_NOTIFIER(Test1Thread), (INT)duration.GetMilliSeconds());
 157   }
 158   cout << endl;
 159
 160   startTick = PTimer::Tick();
 161   while (threadCount > 0) {
 162     Test1Output();
 163     Sleep(5000);
 164   }
 165
 166   Test1OutputEnd();
 167   sorted.RemoveAll();
 168   unsorted.RemoveAll();
 169   sparse.RemoveAll();
 170   Test1OutputEnd();
 171 }
 172
 173
 174 void ThreadSafe::Test1Output()
 175 {
 176   PSafePtr<TestObject> ptr;
 177   sorted.DeleteObjectsToBeRemoved();
 178   unsorted.DeleteObjectsToBeRemoved();
 179   sparse.DeleteObjectsToBeRemoved();
 180
 181   cout << setprecision(0) << setw(5) << (PTimer::Tick() - startTick)
 182        << " Threads=" << threadCount
 183        << ", Unsorted=" << unsorted.GetSize()
 184        << ", Sorted=" << sorted.GetSize()
 185        << ", Dictionary=" << sparse.GetSize()
 186        << ", Objects:";
 187
 188
 189   mutexObjects.Wait();
 190   cout << currentObjects << '/' << totalObjects << endl;
 191   mutexObjects.Signal();
 192
 193 }
 194
 195 void ThreadSafe::Test1OutputEnd()
 196 {
 197   PSafePtr<TestObject> ptr;
 198
 199   Test1Output();
 200
 201   cout << setprecision(0) << setw(5) << (PTimer::Tick() - startTick) << " Unsorted:" << endl;
 202   for (ptr = unsorted.GetWithLock(0, PSafeReference); ptr != NULL; ++ptr) {
 203     cout << *ptr << endl;
 204     }
 205
 206   cout << setprecision(0) << setw(5) << (PTimer::Tick() - startTick) << " Sorted:" << endl;
 207   for (ptr = sorted.GetWithLock(0, PSafeReference); ptr != NULL; ++ptr) {
 208     cout << *ptr << endl;
 209     }
 210
 211   cout << setprecision(0) << setw(5) << (PTimer::Tick() - startTick) << " Sparse:" << endl;
 212   for (ptr = sparse.GetWithLock(0, PSafeReference); ptr != NULL; ++ptr) {
 213     cout << *ptr << endl;
 214     }
 215
 216
 217 }
 218
 219
 220
 221 void ThreadSafe::Test1Thread(PThread &, INT duration)
 222 {
 223   PRandom random;
 224   PSafePtr<TestObject> ptr;
 225
 226   PTimer timeout = duration;
 227
 228   while (timeout.IsRunning()) {
 229     switch (random%17) {
 230       case 0 :
 231         if (random%(unsorted.GetSize()+1) == 0)
 232           unsorted.Append(new TestObject(*this, random));
 233         break;
 234
 235       case 1 :
 236         if (random%(sorted.GetSize()+1) == 0)
 237           sorted.Append(new TestObject(*this, random));
 238         break;
 239
 240       case 2 :
 241         sparse.SetAt(random%20, new TestObject(*this, random));
 242         break;
 243
 244       case 3 :
 245         for (ptr = unsorted.GetWithLock(0, PSafeReference); ptr != NULL; ++ptr) {
 246           if (random%50 == 0)
 247             unsorted.Remove(ptr);
 248         }
 249         break;
 250
 251       case 4 :
 252         for (ptr = sorted.GetWithLock(0, PSafeReference); ptr != NULL; ++ptr) {
 253           if (random%50 == 0)
 254             sorted.Remove(ptr);
 255         }
 256         break;
 257
 258       case 5 :
 259         sparse.RemoveAt(random%20);
 260         break;
 261
 262       case 6 :
 263         for (ptr = unsorted; ptr != NULL; ++ptr)
 264           Sleep(random%50);
 265         break;
 266
 267       case 7 :
 268         for (ptr = sorted; ptr != NULL; ++ptr)
 269           Sleep(random%50);
 270         break;
 271
 272       case 8 :
 273         for (ptr = sparse; ptr != NULL; ++ptr)
 274           Sleep(random%50);
 275         break;
 276
 277       case 9 :
 278         for (ptr = unsorted.GetWithLock(0, PSafeReadOnly); ptr != NULL; ++ptr)
 279           Sleep(random%50);
 280         break;
 281
 282       case 10 :
 283         for (ptr = sorted.GetWithLock(0, PSafeReadOnly); ptr != NULL; ++ptr)
 284           Sleep(random%50);
 285         break;
 286
 287       case 11 :
 288         for (ptr = sparse.GetWithLock(0, PSafeReadOnly); ptr != NULL; ++ptr)
 289           Sleep(random%50);
 290         break;
 291
 292       case 12 :
 293         for (ptr = unsorted.GetWithLock(0, PSafeReference); ptr != NULL; ++ptr)
 294           Sleep(random%50);
 295         break;
 296
 297       case 13 :
 298         for (ptr = sorted.GetWithLock(0, PSafeReference); ptr != NULL; ++ptr)
 299           Sleep(random%50);
 300         break;
 301
 302       case 14 :
 303         for (ptr = sparse.GetWithLock(0, PSafeReference); ptr != NULL; ++ptr)
 304           Sleep(random%50);
 305         break;
 306
 307
 308       case 15 :
 309         if ( unsorted.GetSize() > 0 ) {
 310                 PSafePtr<TestObject> ptr2 = unsorted.GetWithLock(unsorted.GetSize() - 1, PSafeReadOnly);
 311
 312                 if ( ptr2 != NULL )
 313             ptr2 = unsorted.FindWithLock(*ptr2, PSafeReadOnly);
 314                 }
 315
 316         break;
 317
 318       case 16 :
 319         if ( sorted.GetSize() > 0 ) {
 320                 PSafePtr<TestObject> ptr2 = unsorted.GetWithLock(sorted.GetSize() - 1, PSafeReference);
 321
 322                 if ( ptr2 != NULL )
 323             ptr2 = sorted.FindWithLock(*ptr2, PSafeReference);
 324                       }
 325         break;
 326
 327     }
 328     Sleep(random%500);
 329   }
 330
 331   threadCount--;
 332 }
 333
 334
 335 void ThreadSafe::Test2(PArgList &)
 336 {
 337   sparse.SetAt(0, new TestObject(*this, 0));
 338
 339   threadCount = 2;
 340   PThread::Create(PCREATE_NOTIFIER(Test2Thread1));
 341   PThread::Create(PCREATE_NOTIFIER(Test2Thread2));
 342
 343   while (threadCount > 0)
 344     Sleep(1000);
 345 }
 346
 347
 348 void ThreadSafe::Test2Thread1(PThread &, INT)
 349 {
 350   cout << "Thread 1 before read only lock" << endl;
 351   PSafePtr<TestObject> ptr = sparse.FindWithLock(0, PSafeReadOnly);
 352
 353   cout << "Thread 1 after read only lock, pausing ..." << endl;
 354   Sleep(3000);
 355
 356   cout << "Thread 1 before read write lock" << endl;
 357   ptr = sparse.FindWithLock(0, PSafeReadWrite);
 358
 359   cout << "Thread 1 after read write lock, exiting" << endl;
 360
 361   threadCount--;
 362 }
 363
 364
 365 void ThreadSafe::Test2Thread2(PThread &, INT)
 366 {
 367   Sleep(1000);
 368
 369   cout << "Thread 2 before read write lock" << endl;
 370   PSafePtr<TestObject> ptr = sparse.FindWithLock(0, PSafeReadWrite);
 371
 372   cout << "Thread 2 after read write lock, exiting" << endl;
 373   threadCount--;
 374 }
 375
 376
 377 void ThreadSafe::Test3(PArgList &)
 378 {
 379   for (PINDEX i = 0; i < 10; i++)
 380     unsorted.Append(new TestObject(*this, i));
 381
 382   threadCount = 2;
 383   PThread::Create(PCREATE_NOTIFIER(Test3Thread1));
 384   PThread::Create(PCREATE_NOTIFIER(Test3Thread2));
 385
 386   while (threadCount > 0)
 387     Sleep(1000);
 388 }
 389
 390
 391 void ThreadSafe::Test3Thread1(PThread &, INT)
 392 {
 393   {
 394     cout << "Thread 1 before read only lock" << endl;
 395     PSafePtr<TestObject> ptr = unsorted.GetWithLock(2, PSafeReadOnly);
 396
 397     cout << "Thread 1 after read only lock, pausing ..." << endl;
 398     Sleep(2000);
 399
 400     cout << "Thread 1 before read write lock" << endl;
 401     ptr.SetSafetyMode(PSafeReadWrite);
 402
 403     cout << "Thread 1 after read write lock, before ptr going out of scope" << endl;
 404   }
 405   cout << "Thread 1 after ptr out of scope, exiting" << endl;
 406
 407   threadCount--;
 408 }
 409
 410
 411 void ThreadSafe::Test3Thread2(PThread &, INT)
 412 {
 413   Sleep(1000);
 414
 415   cout << "Thread 2 before enumeration" << endl;
 416   PSafePtr<TestObject> ptr = unsorted.GetWithLock(0, PSafeReadOnly);
 417   while (ptr != NULL) {
 418     if (ptr->value == 2) {
 419       cout << "Thread 2 before read write lock" << endl;
 420       ptr->LockReadWrite();
 421       cout << "Thread 2 after read write lock" << endl;
 422
 423       Sleep(2000);
 424
 425       cout << "Thread 2 before read write unlock" << endl;
 426       ptr->UnlockReadWrite();
 427       cout << "Thread 2 after read write unlock" << endl;
 428     }
 429     ptr++;
 430   }
 431
 432   cout << "Thread 2 after enumeration, exiting" << endl;
 433   threadCount--;
 434 }
 435
 436
 437 // End of File ///////////////////////////////////////////////////////////////