port remaining tests to std::mutex

diff --git a/tests/base/task_11.cc b/tests/base/task_11.cc
index 96559b190c1cee8f0cdf98400d309b20dea5a6f4..1afc82aaf4f4b3f32b2ce6d95d2322a747eb6fa0 100644 (file)
--- a/tests/base/task_11.cc
+++ b/tests/base/task_11.cc
@@ -36,9 +36,9 @@ a_task()
   // here.
   std::this_thread::sleep_for(std::chrono::seconds(1));
 
-  mutex.acquire();
+  mutex.lock();
   n_running--;
-  mutex.release();
+  mutex.unlock();
 }
 
 
@@ -51,13 +51,13 @@ test()
   n_max_running = 0;
 
   // force all tasks to wait until we are done starting
-  mutex.acquire();
+  mutex.lock();
 
   for (unsigned int t = 0; t < 10; ++t)
     tg += Threads::new_task(a_task);
 
   // now let the tasks run
-  mutex.release();
+  mutex.unlock();
 
   tg.join_all();
 }

diff --git a/tests/base/thread_local_storage_05.cc b/tests/base/thread_local_storage_05.cc
index e5d861358a9fb837bdc055a26def00d05f1419fb..40b47f789ea7a7d055314ea4e0bc1e351210dc5d 100644 (file)
--- a/tests/base/thread_local_storage_05.cc
+++ b/tests/base/thread_local_storage_05.cc
@@ -51,8 +51,8 @@ execute(Threads::Mutex &m)
   AssertThrow(exists == true, ExcInternalError());
 
   // wait for the barrier to clear
-  m.acquire();
-  m.release();
+  m.lock();
+  m.unlock();
 
   // at this point, the tls object should have been cleared and should
   // be back at its original value
@@ -68,22 +68,22 @@ test()
   const unsigned int N = 10;
   Threads::Mutex     m[N];
 
-  // start N threads with mutices locked
+  // start N threads with mutexes locked
   Threads::ThreadGroup<> tg;
   for (unsigned int i = 0; i < N; ++i)
     {
-      m[i].acquire();
+      m[i].lock();
       tg += Threads::new_thread(execute, m[i]);
     }
 
   // let threads work through their first part
   std::this_thread::sleep_for(std::chrono::seconds(3));
 
-  // then reset the thread local object and release the mutices so the
+  // then reset the thread local object and release the mutexes so the
   // threads can actually run to an end
   tls_data.clear();
   for (unsigned int i = 0; i < N; ++i)
-    m[i].release();
+    m[i].unlock();
 
   // now make sure the threads all finish
   tg.join_all();

diff --git a/tests/base/thread_local_storage_06.cc b/tests/base/thread_local_storage_06.cc
index ccf74a4fa412e0c47d3ef2379e131d9049b9e746..005692ae8f90188ec29be279a74690f1724de62a 100644 (file)
--- a/tests/base/thread_local_storage_06.cc
+++ b/tests/base/thread_local_storage_06.cc
@@ -63,8 +63,8 @@ execute(Threads::Mutex &m)
   AssertThrow(exists == true, ExcInternalError());
 
   // wait for the barrier to clear
-  m.acquire();
-  m.release();
+  m.lock();
+  m.unlock();
 
   // at this point, the tls object should have been cleared and should
   // be back at its original value
@@ -80,22 +80,22 @@ test()
   const unsigned int N = 10;
   Threads::Mutex     m[N];
 
-  // start N threads with mutices locked
+  // start N threads with mutexes locked
   Threads::ThreadGroup<> tg;
   for (unsigned int i = 0; i < N; ++i)
     {
-      m[i].acquire();
+      m[i].lock();
       tg += Threads::new_thread(execute, m[i]);
     }
 
   // let threads work through their first part
   std::this_thread::sleep_for(std::chrono::seconds(3));
 
-  // then reset the thread local object and release the mutices so the
+  // then reset the thread local object and release the mutexes so the
   // threads can actually run to an end
   tls_data.clear();
   for (unsigned int i = 0; i < N; ++i)
-    m[i].release();
+    m[i].unlock();
 
   // now make sure the threads all finish
   tg.join_all();

diff --git a/tests/base/thread_validity_08.cc b/tests/base/thread_validity_08.cc
index ba562c2d59097de6f2b047cb25ec44c46c257142..9bec1301d1b2778158eed08166089b01723cd48c 100644 (file)
--- a/tests/base/thread_validity_08.cc
+++ b/tests/base/thread_validity_08.cc
@@ -33,8 +33,8 @@ worker()
   // wait for the mutex to make sure the main
   // thread has already moved on. we can immediately
   // release the mutex again.
-  mutex.acquire();
-  mutex.release();
+  mutex.lock();
+  mutex.unlock();
   deallog << "OK." << std::endl;
   spin_lock = 1;
 }
@@ -46,7 +46,7 @@ main()
 {
   initlog();
 
-  mutex.acquire();
+  mutex.lock();
   // start and abandon the
   // thread. because we hold the
   // lock, the started task can not
@@ -66,7 +66,7 @@ main()
   std::this_thread::sleep_for(std::chrono::seconds(1));
 
   // let abandoned thread continue
-  mutex.release();
+  mutex.unlock();
 
   // wait for thread to finish
   while (spin_lock == 0)

diff --git a/tests/base/thread_validity_09.cc b/tests/base/thread_validity_09.cc
index 159895d45f92ec1ec2bdb6b481861b6de780a6a2..6c56e2e80a9dde3315785353c09f9c24ded4a5dc 100644 (file)
--- a/tests/base/thread_validity_09.cc
+++ b/tests/base/thread_validity_09.cc
@@ -38,10 +38,10 @@ worker()
   // mutex. release the mutex again at the end of this function since
   // mutices can only be released on the same thread as they are
   // acquired on.
-  mutex.acquire();
+  mutex.lock();
   deallog << "OK." << std::endl;
   spin_lock = 1;
-  mutex.release();
+  mutex.unlock();
   return 42;
 }
 
@@ -52,7 +52,7 @@ main()
 {
   initlog();
 
-  mutex.acquire();
+  mutex.lock();
   {
     Threads::new_thread(worker);
   }
@@ -64,7 +64,7 @@ main()
     p[i] = 0;
 
   // make sure the worker thread can actually start
-  mutex.release();
+  mutex.unlock();
 
   // wait for the worker thread to do its work
   while (spin_lock == 0)