sync-classlock-test.cpp

Go to the documentation of this file.

/*
  SyncClasslock(Test)  -  validate the type-based Monitor locking
 
   Copyright (C)
     2008,            Hermann Vosseler <Ichthyostega@web.de>
 
 **Lumiera** is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 Free Software Foundation; either version 2 of the License, or (at your
 option) any later version. See the file COPYING for further details.
 
* *****************************************************************/
 
#include "lib/test/run.hpp"
#include "lib/sync-classlock.hpp"
#include "lib/scoped-collection.hpp"
#include "lib/thread.hpp"
 
using test::Test;
//using vault::ThreadJoinable;  //////////////////WIP
 
namespace lib {
namespace test {
  
  namespace { // Parameters for multithreaded contention test
    
    const uint NUM_THREADS = 20;   
    const uint NUM_LOOP    = 1000; 
    
  }
  
  
  
  
  /**********************************************************************/
  class SyncClasslock_test : public Test
    {
      
      virtual void
      run (Arg)
        {
          seedRand();
          auto gen = buildCappedSubSequence(defaultGen);
          int contended = 0;
          
          using Threads = lib::ScopedCollection<ThreadJoinable<>>;
          
               // Start a bunch of threads with random access pattern
          Threads threads{NUM_THREADS,
                          [&](Threads::ElementHolder& storage)
                             {
                               storage.create<ThreadJoinable<>> ("Sync-ClassLock stress test"
                                                                ,[&]{
                                                                      for (uint i=0; i<NUM_LOOP; ++i)
                                                                        {
                                                                          uint delay = gen.i(10);
                                                                          usleep (delay);
                                                                          {
                                                                            ClassLock<void> guard;
                                                                            ++contended;
                                                                          }
                                                                        }
                                                                    });
                             }
                         };
          
          for (auto& thread : threads)
            thread.join(); // block until thread terminates   // @suppress("Return value not evaluated")
          
          CHECK (contended == NUM_THREADS * NUM_LOOP,
                 "ALARM: Lock failed, concurrent modification "
                 "during counter increment. Delta == %d"
                ,NUM_THREADS * NUM_LOOP - contended);
        }
      
    };
  
  
  
  LAUNCHER (SyncClasslock_test, "unit common");
  
  
  
}} // namespace lib::test