From 52ec3b8dcb1a6116b716a0f6459e76b4c8a95bb2 Mon Sep 17 00:00:00 2001 From: Wolfgang Bangerth Date: Thu, 27 Sep 2018 16:27:08 -0600 Subject: [PATCH] Remove the DummyMutex/ConditionVariable/Barrier classes. We provided these in cases where someone wanted to not compile for multithreading, in which case certain functionality from the TBB was not available. But the implementations of these classes is now unconditionally available via the C++11 standard library, and so we don't need the dummy implementations any more. --- include/deal.II/base/thread_management.h | 214 +---------------------- 1 file changed, 3 insertions(+), 211 deletions(-) diff --git a/include/deal.II/base/thread_management.h b/include/deal.II/base/thread_management.h index 7ed6874880..32050b2668 100644 --- a/include/deal.II/base/thread_management.h +++ b/include/deal.II/base/thread_management.h @@ -63,190 +63,6 @@ DEAL_II_NAMESPACE_OPEN */ namespace Threads { - /** - * This class is used instead of a true lock class when not using - * multithreading. It allows to write programs such that they start new - * threads and/or lock objects in multithreading mode, and use dummy thread - * management and synchronization classes instead when running in single- - * thread mode. Specifically, the new_thread() functions only call the - * function but wait for it to return instead of running in on another - * thread, and the mutexes do nothing really. The only reason to provide - * such a function is that the program can be compiled both in MT and non-MT - * mode without difference. - * - * @author Wolfgang Bangerth, 2000, 2003 - */ - class DummyThreadMutex - { - public: - /** - * Scoped lock class. When you declare an object of this type, you have to - * pass it a mutex, which is locked in the constructor of this class and - * unlocked in the destructor. The lock is thus held during the entire - * lifetime of this object, i.e. until the end of the present scope, which - * explains where the name comes from. This pattern of using locks with - * mutexes follows the resource-acquisition-is-initialization pattern, and - * was used first for mutexes by Doug Schmidt. It has the advantage that - * locking a mutex this way is thread-safe, i.e. when an exception is - * thrown between the locking and unlocking point, the destructor makes - * sure that the mutex is unlocked; this would not automatically be the - * case when you lock and unlock the mutex "by hand", i.e. using - * Mutex::acquire() and Mutex::release(). - */ - class ScopedLock - { - public: - /** - * Constructor. Lock the mutex. Since this is a dummy mutex class, this - * of course does nothing. - */ - ScopedLock(DummyThreadMutex &) - {} - - /** - * Destructor. Unlock the mutex. Since this is a dummy mutex class, this - * of course does nothing. We still don't declare it as 'default' to avoid - * warnings about objects of this class being unused. - */ - ~ScopedLock() - {} - }; - - /** - * Simulate acquisition of the mutex. As this class does nothing really, - * this function does nothing as well. - */ - inline void - acquire() const - {} - - /** - * Simulate release of the mutex. As this class does nothing really, this - * function does nothing as well. - */ - inline void - release() const - {} - }; - - - - /** - * This class is used in single threaded mode instead of a class - * implementing real condition variable semantics. It allows to write - * programs such that they start new threads and/or lock objects in - * multithreading mode, and use dummy thread management and synchronization - * classes instead when running in single-thread mode. Specifically, the - * new_thread() functions only call the function but wait for it to return - * instead of running in on another thread, and the mutexes do nothing - * really. The only reason to provide such a function is that the program - * can be compiled both in MT and non-MT mode without difference. - * - * In this particular case, just as with mutexes, the functions do nothing, - * and by this provide the same semantics of condition variables as in - * multi-threaded mode. - * - * @author Wolfgang Bangerth, 2003 - */ - class DummyThreadCondition - { - public: - /** - * Signal to a single listener that a condition has been met, i.e. that - * some data will now be available. Since in single threaded mode, this - * function of course does nothing. - */ - inline void - signal() const - {} - - /** - * Signal to multiple listener that a condition has been met, i.e. that - * some data will now be available. Since in single threaded mode, this - * function of course does nothing. - */ - inline void - broadcast() const - {} - - /** - * Wait for the condition to be signalled. Signal variables need to be - * guarded by a mutex which needs to be given to this function as an - * argument, see the man page of posix_cond_wait for a - * description of the mechanisms. Since in single threaded mode, this - * function of course does nothing, but returns immediately. - */ - inline void - wait(DummyThreadMutex &) const - {} - }; - - - - /** - * This class is used instead of a true barrier class when not using - * multithreading. It allows to write programs such that they use the same - * class names in multithreading and non-MT mode and thus may be compiled - * with or without thread-support without the need to use conditional - * compilation. Since a barrier class only makes sense in non-multithread - * mode if only one thread is to be synchronized (otherwise, the barrier - * could not be left, since the one thread is waiting for some other part of - * the program to reach a certain point of execution), the constructor of - * this class throws an exception if the count argument - * denoting the number of threads that need to be synchronized is not equal - * to one. - * - * @author Wolfgang Bangerth, 2001 - */ - class DummyBarrier - { - public: - /** - * Constructor. Since barriers are only useful in single-threaded mode if - * the number of threads to be synchronized is one, this constructor - * raises an exception if the count argument is one. - */ - DummyBarrier(const unsigned int count, - const char * name = nullptr, - void * arg = nullptr); - - /** - * Wait for all threads to reach this point. Since there may only be one - * thread, return immediately, i.e. this function is a no-op. - */ - inline int - wait() const - { - return 0; - } - - /** - * Dump the state of this object. Here: do nothing. - */ - inline void - dump() const - {} - - /** - * @addtogroup Exceptions - * @{ - */ - - /** - * Exception. - */ - DeclException1( - ExcBarrierSizeNotUseful, - int, - << "In single-thread mode, barrier sizes other than 1 are not " - << "useful. You gave " << arg1 << "."); - - //@} - }; - - -# ifdef DEAL_II_WITH_THREADS - /** * A class implementing a mutex. @@ -452,11 +268,11 @@ namespace Threads * Data object storing the POSIX data which we need to call the POSIX * functions. */ -# ifndef DEAL_II_USE_MT_POSIX_NO_BARRIERS +# ifndef DEAL_II_USE_MT_POSIX_NO_BARRIERS pthread_barrier_t barrier; -# else +# else unsigned int count; -# endif +# endif }; @@ -468,30 +284,6 @@ namespace Threads * is deprecated. */ using Barrier DEAL_II_DEPRECATED = PosixThreadBarrier; - -# else - /** - * In non-multithread mode, the mutex and thread management classes are - * aliased to dummy classes that actually do nothing, in particular not lock - * objects. Likewise for the barrier class. - */ - using Mutex = DummyThreadMutex; - - /** - * In non-multithread mode, the mutex and thread management classes are - * aliased to dummy classes that actually do nothing, in particular not lock - * objects. Likewise for the barrier class. - */ - using ConditionVariable = DummyThreadCondition; - - /** - * In non-multithread mode, the mutex and thread management classes are - * aliased to dummy classes that actually do nothing, in particular not lock - * objects. Likewise for the barrier class. - */ - using Barrier = DummyBarrier; -# endif - } // namespace Threads -- 2.39.5