LCOV - code coverage report
Current view: top level - lunchbox - monitor.h (source / functions) Hit Total Coverage
Test: Lunchbox Lines: 76 77 98.7 %
Date: 2018-10-03 05:33:11 Functions: 63 64 98.4 %

          Line data    Source code
       1             : /* Copyright (c) 2006-2017, Stefan Eilemann <eile@equalizergraphics.com>
       2             :  *                          Cedric Stalder <cedric.stalder@gmail.com>
       3             :  *                          Daniel Nachbaur <danielnachbaur@gmail.com>
       4             :  *
       5             :  * This library is free software; you can redistribute it and/or modify it under
       6             :  * the terms of the GNU Lesser General Public License version 2.1 as published
       7             :  * by the Free Software Foundation.
       8             :  *
       9             :  * This library is distributed in the hope that it will be useful, but WITHOUT
      10             :  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
      11             :  * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
      12             :  * details.
      13             :  *
      14             :  * You should have received a copy of the GNU Lesser General Public License
      15             :  * along with this library; if not, write to the Free Software Foundation, Inc.,
      16             :  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
      17             :  */
      18             : 
      19             : #ifndef LUNCHBOX_MONITOR_H
      20             : #define LUNCHBOX_MONITOR_H
      21             : 
      22             : #include <lunchbox/scopedMutex.h> // used inline
      23             : #include <lunchbox/types.h>
      24             : 
      25             : #include <boost/bind.hpp>
      26             : #include <condition_variable>
      27             : #include <errno.h>
      28             : #include <functional>
      29             : #include <iostream>
      30             : #include <mutex>
      31             : #include <string.h>
      32             : #include <typeinfo>
      33             : 
      34             : namespace lunchbox
      35             : {
      36             : /**
      37             :  * A monitor primitive.
      38             :  *
      39             :  * A monitor has a value, which can be monitored to reach a certain state. The
      40             :  * caller is blocked until the condition is fulfilled. The concept is similar to
      41             :  * a pthread condition, with more usage convenience.
      42             :  *
      43             :  * Example: @include tests/monitor.cpp
      44             :  */
      45             : template <class T>
      46             : class Monitor
      47             : {
      48             :     typedef void (Monitor<T>::*bool_t)() const;
      49           0 :     void bool_true() const {}
      50             : public:
      51             :     /** Construct a new monitor with a default value of 0. @version 1.0 */
      52           2 :     Monitor()
      53           2 :         : _value(T(0))
      54             :     {
      55           2 :     }
      56             : 
      57             :     /** Construct a new monitor with a given default value. @version 1.0 */
      58        1641 :     explicit Monitor(const T& value)
      59        1641 :         : _value(value)
      60             :     {
      61        1641 :     }
      62             : 
      63             :     /** Ctor initializing with the given monitor value. @version 1.1.5 */
      64             :     Monitor(const Monitor<T>& from)
      65             :         : _value(from._value)
      66             :     {
      67             :     }
      68             : 
      69             :     /** Destructs the monitor. @version 1.0 */
      70        1644 :     ~Monitor() {}
      71             :     /** @name Changing the monitored value. */
      72             :     //@{
      73             :     /** Increment the monitored value, prefix only. @version 1.0 */
      74     2002000 :     Monitor& operator++()
      75             :     {
      76     4004000 :         std::unique_lock<std::mutex> lock(_mutex);
      77     2002000 :         ++_value;
      78     2002000 :         _condition.notify_all();
      79     4004000 :         return *this;
      80             :     }
      81             : 
      82             :     /** Decrement the monitored value, prefix only. @version 1.0 */
      83     2002000 :     Monitor& operator--()
      84             :     {
      85     4004000 :         std::unique_lock<std::mutex> lock(_mutex);
      86     2002000 :         --_value;
      87     2002000 :         _condition.notify_all();
      88     4004000 :         return *this;
      89             :     }
      90             : 
      91             :     /** Assign a new value. @version 1.0 */
      92      830622 :     Monitor& operator=(const T& value)
      93             :     {
      94      830622 :         set(value);
      95      830632 :         return *this;
      96             :     }
      97             : 
      98             :     /** Assign a new value. @version 1.1.5 */
      99             :     const Monitor& operator=(const Monitor<T>& from)
     100             :     {
     101             :         set(from._value);
     102             :         return *this;
     103             :     }
     104             : 
     105             :     /** Perform an or operation on the value. @version 1.0 */
     106             :     Monitor& operator|=(const T& value)
     107             :     {
     108             :         std::unique_lock<std::mutex> lock(_mutex);
     109             :         _value |= value;
     110             :         _condition.notify_all();
     111             :         return *this;
     112             :     }
     113             : 
     114             :     /** Perform an and operation on the value. @version 1.7 */
     115             :     Monitor& operator&=(const T& value)
     116             :     {
     117             :         std::unique_lock<std::mutex> lock(_mutex);
     118             :         _value &= value;
     119             :         _condition.notify_all();
     120             :         return *this;
     121             :     }
     122             : 
     123             :     /** Set a new value. @return the old value @version 1.0 */
     124      830622 :     T set(const T& value)
     125             :     {
     126     1661254 :         std::unique_lock<std::mutex> lock(_mutex);
     127      830624 :         const T old = _value;
     128      830624 :         _value = value;
     129      830624 :         _condition.notify_all();
     130     1661264 :         return old;
     131             :     }
     132             :     //@}
     133             : 
     134             :     /** @name Monitor the value. */
     135             :     //@{
     136             :     /**
     137             :      * Block until the monitor has the given value.
     138             :      * @return the value when reaching the condition.
     139             :      * @version 1.0
     140             :      */
     141      400000 :     const T waitEQ(const T& value) const
     142             :     {
     143     1199961 :         return _wait([&] { return _value == value; });
     144             :     }
     145             : 
     146             :     /**
     147             :      * Block until the monitor has not the given value.
     148             :      * @return the value when reaching the condition.
     149             :      * @version 1.0
     150             :      */
     151       11305 :     const T waitNE(const T& value) const
     152             :     {
     153       32307 :         return _wait([&] { return _value != value; });
     154             :     }
     155             : 
     156             :     /**
     157             :      * Block until the monitor has none of the given values.
     158             :      * @return the value when reaching the condition.
     159             :      * @version 1.0
     160             :      */
     161             :     const T waitNE(const T& v1, const T& v2) const
     162             :     {
     163             :         std::unique_lock<std::mutex> lock(_mutex);
     164             :         _condition.wait(lock, [&] { return _value != v1 && _value != v2; });
     165             :         return _value;
     166             :     }
     167             : 
     168             :     /**
     169             :      * Block until the monitor has a value greater or equal to the given value.
     170             :      * @return the value when reaching the condition.
     171             :      * @version 1.0
     172             :      */
     173        1000 :     const T waitGE(const T& value) const
     174             :     {
     175       79715 :         return _wait([&] { return _value >= value; });
     176             :     }
     177             : 
     178             :     /**
     179             :      * Block until the monitor has a value less or equal to the given value.
     180             :      * @return the value when reaching the condition.
     181             :      * @version 1.0
     182             :      */
     183       61227 :     const T waitLE(const T& value) const
     184             :     {
     185      199372 :         return _wait([&] { return _value <= value; });
     186             :     }
     187             : 
     188             :     /**
     189             :      * Block until the monitor has a value greater than the given value.
     190             :      * @return the value when reaching the condition.
     191             :      * @version 1.10
     192             :      */
     193        1000 :     const T waitGT(const T& value) const
     194             :     {
     195       81465 :         return _wait([&] { return _value > value; });
     196             :     }
     197             : 
     198             :     /**
     199             :      * Block until the monitor has a value less than the given value.
     200             :      * @return the value when reaching the condition.
     201             :      * @version 1.10
     202             :      */
     203        1000 :     const T waitLT(const T& value) const
     204             :     {
     205       79400 :         return _wait([&] { return _value < value; });
     206             :     }
     207             : 
     208             :     /** @name Monitor the value with a timeout. */
     209             :     //@{
     210             :     /**
     211             :      * Block until the monitor has the given value.
     212             :      * @param value the exact value to monitor.
     213             :      * @param timeout the timeout in milliseconds to wait for the value.
     214             :      * @return true on success, false on timeout.
     215             :      * @version 1.1
     216             :      */
     217             :     bool timedWaitEQ(const T& value, const uint32_t timeout) const
     218             :     {
     219             :         return _timedWait([&] { return _value == value; }, timeout);
     220             :     }
     221             : 
     222             :     /**
     223             :      * Block until the monitor has not the given value.
     224             :      * @param value the exact value to monitor.
     225             :      * @param timeout the timeout in milliseconds to wait for not the value.
     226             :      * @return true on success, false on timeout.
     227             :      * @version 1.10
     228             :      */
     229             :     bool timedWaitNE(const T& value, const uint32_t timeout) const
     230             :     {
     231             :         return _timedWait([&] { return _value != value; }, timeout);
     232             :     }
     233             : 
     234             :     /**
     235             :      * Block until the monitor has a value greater or equal to the given value.
     236             :      * @param value the exact value to monitor.
     237             :      * @param timeout the timeout in milliseconds to wait for the value.
     238             :      * @return true on success, false on timeout.
     239             :      * @version 1.1
     240             :      */
     241        1278 :     bool timedWaitGE(const T& value, const uint32_t timeout) const
     242             :     {
     243       60315 :         return _timedWait([&] { return _value >= value; }, timeout);
     244             :     }
     245             : 
     246             :     /**
     247             :      * Block until the monitor has a value less or equal to the given value.
     248             :      * @param value the exact value to monitor.
     249             :      * @param timeout the timeout in milliseconds to wait for the value.
     250             :      * @return true on success, false on timeout.
     251             :      * @version 1.10
     252             :      */
     253        1346 :     bool timedWaitLE(const T& value, const uint32_t timeout) const
     254             :     {
     255       63896 :         return _timedWait([&] { return _value <= value; }, timeout);
     256             :     }
     257             : 
     258             :     /**
     259             :      * Block until the monitor has a value greater than the given value.
     260             :      * @param value the exact value to monitor.
     261             :      * @param timeout the timeout in milliseconds to wait for the value.
     262             :      * @return true on success, false on timeout.
     263             :      * @version 1.10
     264             :      */
     265        1324 :     bool timedWaitGT(const T& value, const uint32_t timeout) const
     266             :     {
     267       61694 :         return _timedWait([&] { return _value > value; }, timeout);
     268             :     }
     269             : 
     270             :     /**
     271             :      * Block until the monitor has a value less than the given value.
     272             :      * @param value the exact value to monitor.
     273             :      * @param timeout the timeout in milliseconds to wait for the value.
     274             :      * @return true on success, false on timeout.
     275             :      * @version 1.10
     276             :      */
     277        1377 :     bool timedWaitLT(const T& value, const uint32_t timeout) const
     278             :     {
     279       64369 :         return _timedWait([&] { return _value < value; }, timeout);
     280             :     }
     281             : 
     282             :     //@}
     283             : 
     284             :     /** @name Comparison Operators. @version 1.0 */
     285             :     //@{
     286        2157 :     bool operator==(const T& value) const
     287             :     {
     288        4314 :         std::unique_lock<std::mutex> lock(_mutex);
     289        4314 :         return _value == value;
     290             :     }
     291      184008 :     bool operator!=(const T& value) const
     292             :     {
     293      368016 :         std::unique_lock<std::mutex> lock(_mutex);
     294      368016 :         return _value != value;
     295             :     }
     296        2000 :     bool operator<(const T& value) const
     297             :     {
     298        4000 :         std::unique_lock<std::mutex> lock(_mutex);
     299        4000 :         return _value < value;
     300             :     }
     301     4006000 :     bool operator>(const T& value) const
     302             :     {
     303     8012000 :         std::unique_lock<std::mutex> lock(_mutex);
     304     8012000 :         return _value > value;
     305             :     }
     306        2000 :     bool operator<=(const T& value) const
     307             :     {
     308        4000 :         std::unique_lock<std::mutex> lock(_mutex);
     309        4000 :         return _value <= value;
     310             :     }
     311        2000 :     bool operator>=(const T& value) const
     312             :     {
     313        4000 :         std::unique_lock<std::mutex> lock(_mutex);
     314        4000 :         return _value >= value;
     315             :     }
     316             : 
     317             :     bool operator==(const Monitor<T>& rhs) const
     318             :     {
     319             :         std::unique_lock<std::mutex> lock(_mutex);
     320             :         return _value == rhs._value;
     321             :     }
     322             :     bool operator!=(const Monitor<T>& rhs) const
     323             :     {
     324             :         std::unique_lock<std::mutex> lock(_mutex);
     325             :         return _value != rhs._value;
     326             :     }
     327             :     bool operator<(const Monitor<T>& rhs) const
     328             :     {
     329             :         std::unique_lock<std::mutex> lock(_mutex);
     330             :         return _value < rhs._value;
     331             :     }
     332             :     bool operator>(const Monitor<T>& rhs) const
     333             :     {
     334             :         std::unique_lock<std::mutex> lock(_mutex);
     335             :         return _value > rhs._value;
     336             :     }
     337             :     bool operator<=(const Monitor<T>& rhs) const
     338             :     {
     339             :         std::unique_lock<std::mutex> lock(_mutex);
     340             :         return _value <= rhs._value;
     341             :     }
     342             :     bool operator>=(const Monitor<T>& rhs) const
     343             :     {
     344             :         std::unique_lock<std::mutex> lock(_mutex);
     345             :         return _value >= rhs._value;
     346             :     }
     347             :     /** @return a bool conversion of the result. @version 1.9.1 */
     348           2 :     operator bool_t()
     349             :     {
     350           4 :         std::unique_lock<std::mutex> lock(_mutex);
     351           4 :         return _value ? &Monitor<T>::bool_true : 0;
     352             :     }
     353             :     //@}
     354             : 
     355             :     /** @name Data Access. */
     356             :     //@{
     357             :     /** @return the current value. @version 1.0 */
     358             :     const T& operator->() const { return _value; }
     359             :     /** @return the current value. @version 1.0 */
     360             :     const T& get() const { return _value; }
     361             :     /** @return the current plus the given value. @version 1.0 */
     362             :     T operator+(const T& value) const
     363             :     {
     364             :         std::unique_lock<std::mutex> lock(_mutex);
     365             :         return _value + value;
     366             :     }
     367             : 
     368             :     /** @return the current or'ed with the given value. @version 1.0 */
     369             :     T operator|(const T& value) const
     370             :     {
     371             :         std::unique_lock<std::mutex> lock(_mutex);
     372             :         return static_cast<T>(_value | value);
     373             :     }
     374             : 
     375             :     /** @return the current and the given value. @version 1.0 */
     376             :     T operator&(const T& value) const
     377             :     {
     378             :         std::unique_lock<std::mutex> lock(_mutex);
     379             :         return static_cast<T>(_value & value);
     380             :     }
     381             :     //@}
     382             : 
     383             : private:
     384             :     T _value;
     385             :     mutable std::mutex _mutex;
     386             :     mutable std::condition_variable _condition;
     387             : 
     388             :     template <typename F>
     389      475532 :     const T _wait(const F& predicate) const
     390             :     {
     391      951064 :         std::unique_lock<std::mutex> lock(_mutex);
     392      475532 :         _condition.wait(lock, predicate);
     393      951064 :         return _value;
     394             :     }
     395             : 
     396             :     template <typename F>
     397        5325 :     bool _timedWait(const F& predicate, const uint32_t timeout) const
     398             :     {
     399       10650 :         std::unique_lock<std::mutex> lock(_mutex);
     400             :         return _condition.wait_for(lock, std::chrono::milliseconds(timeout),
     401       10650 :                                    predicate);
     402             :     }
     403             : };
     404             : 
     405             : typedef Monitor<bool> Monitorb;     //!< A boolean monitor variable
     406             : typedef Monitor<uint32_t> Monitoru; //!< An unsigned 32bit integer monitor
     407             : 
     408             : /** Print the monitor to the given output stream. @version 1.0 */
     409             : template <typename T>
     410             : inline std::ostream& operator<<(std::ostream& os, const Monitor<T>& monitor)
     411             : {
     412             :     os << "Monitor< " << monitor.get() << " >";
     413             :     return os;
     414             : }
     415             : 
     416             : template <>
     417             : inline Monitor<bool>& Monitor<bool>::operator++()
     418             : {
     419             :     std::unique_lock<std::mutex> lock(_mutex);
     420             :     assert(!_value);
     421             :     _value = !_value;
     422             :     _condition.notify_all();
     423             :     return *this;
     424             : }
     425             : 
     426             : template <>
     427             : inline Monitor<bool>& Monitor<bool>::operator--()
     428             : {
     429             :     std::unique_lock<std::mutex> lock(_mutex);
     430             :     assert(!_value);
     431             :     _value = !_value;
     432             :     _condition.notify_all();
     433             :     return *this;
     434             : }
     435             : 
     436             : template <>
     437             : inline Monitor<bool>& Monitor<bool>::operator|=(const bool& value)
     438             : {
     439             :     if (value)
     440             :     {
     441             :         std::unique_lock<std::mutex> lock(_mutex);
     442             :         _value = value;
     443             :         _condition.notify_all();
     444             :     }
     445             :     return *this;
     446             : }
     447             : }
     448             : 
     449             : #include <servus/uint128_t.h>
     450             : namespace lunchbox
     451             : {
     452             : template <>
     453           1 : inline Monitor<servus::uint128_t>::Monitor()
     454             : {
     455           1 : }
     456             : }
     457             : 
     458             : #endif // LUNCHBOX_MONITOR_H

Generated by: LCOV version 1.11