Merge branch 'iss-65' into develop

Author: Herbert Koelman

include/pthread/exceptions.hpp

@@ -88,6 +88,20 @@ namespace pthread {
 
   };
 
+  /** throw to indicate that something went wrong with a read/write lock
+   */
+  class read_write_lock_exception: public pthread_exception {
+  public:
+
+    /** thrown when read_write_lock actions fail
+     *
+     * @param message short description
+     * @param pthread_errno error returned by the pthread function
+     */
+    explicit read_write_lock_exception( const std::string &message, const int pthread_errno = -1) ;
+    
+  };
+
   /** Condition variable exception
    */
   class condition_variable_exception: public pthread_exception {

include/pthread/lock_guard.hpp

@@ -47,8 +47,9 @@ namespace pthread {
      *
      * @param m reference to a valid pthread::mutex
      */
-    explicit lock_guard(MutexType &m): _mutex(&m) {
-        _mutex->lock();
+    explicit lock_guard(MutexType &m){ //: _mutex(&m) {
+      _mutex = &m ;
+      _mutex->lock();
     }
 
     /** The destructor release the guarded mutex.

include/pthread/pthread.hpp

@@ -20,6 +20,7 @@
 
 #include "pthread/config.h"
 #include "pthread/mutex.hpp"
+#include "pthread/read_write_lock.hpp"
 #include "pthread/lock_guard.hpp"
 #include "pthread/condition_variable.hpp"
 #include "pthread/thread.hpp"

include/pthread/read_write_lock.hpp

@@ -0,0 +1,144 @@
+//
+//  read_write_lock.hpp
+//  read_write_lock
+//
+//  Created by herbert koelman on 18/03/2016.
+//
+//
+
+#ifndef pthread_read_write_lock_hpp
+#define pthread_read_write_lock_hpp
+
+// must be include as first hearder file of each source code file (see IBM's
+// recommandation for more info p.285 §8.3.1).
+#include <pthread.h>
+
+#include "pthread/config.h"
+#include "pthread/exceptions.hpp"
+
+
+namespace pthread {
+  
+  /** \addtogroup concurrency
+   *
+   * @{
+   */
+
+  /** This class acquires the read lock.
+   *
+   * This class cannot be instaiated as it's main putpose is to implement read locks. To use a read lock create 
+   * either a read_write_lock or a write_lock.
+   *
+   * @author herbert koelman ([email protected])
+   * @since v1.6.0
+   * @see pthread::read_write_lock
+   */
+  class read_lock {
+    public:
+
+      /** The method apply a read lock.
+       *
+       * The calling thread acquires the write lock if no other thread (reader or writer) holds the read-write lock. Otherwise, the thread shall block until
+       * it can acquire the lock. The calling thread may deadlock if at the time the call is made it holds the read-write lock (whether a read or write lock).
+       */
+      void lock ();
+      
+      /** The method shall apply a read lock, if any thread currently holds the lock (for reading or writing) 
+       * the method throws an exception.
+       *
+       @see lock
+       */
+      void try_lock ();
+      
+      /** release the read lock.
+       @throw read_write_lock_exception if error conditions preventing this method to succeed.
+       */
+      void unlock ();
+    
+
+      /**
+       * the descructor, shall destroy the read-write lock object referenced by rwlock and release any resources used by the lock.
+       */
+       virtual ~read_lock ();
+
+    protected:
+    
+      /**
+       Constructor/Desctructor
+     
+       this constructor shall allocate any resources required to use the read-write lock referenced by rwlock and initializes the lock to an unlocked state. The read/write lock
+       passes NULL attributes. This means default behavior.
+     
+       @throw read_write_lock_exception if error conditions preventing this method to succeed.
+       */
+      read_lock ();
+    
+      /** read/write lock reference */
+      pthread_rwlock_t _rwlock;
+  };
+
+  /** This class acquires the read/write write lock
+   *
+   * @author herbert koelman ([email protected])
+   * @since v1.6.0
+   */
+  class write_lock: public read_lock {
+    public:
+      /** The method apply a write lock.
+       *
+       * The calling thread acquires the write lock if no other thread (reader or writer) holds the read-write lock. Otherwise, the thread shall block until
+       * it can acquire the lock. The calling thread may deadlock if at the time the call is made it holds the read-write lock (whether a read or write lock).
+       */
+      void lock ();
+      
+      /** The method shall apply a write lock, if any thread currently holds the lock (for reading or writing) 
+       * the method throws an exception.
+       *
+       @see lock
+       */
+      void try_lock ();
+      
+      /**
+       Constructor/Desctructor
+
+       this constructor shall allocate any resources required to use the read-write lock referenced by rwlock and initializes the lock to an unlocked state. The read/write lock
+       passes NULL attributes. This means default behavior.
+
+       @throw read_write_lock_exception if error conditions preventing this method to succeed.
+       */
+       write_lock ();
+
+      /**
+       * the descructor, shall destroy the read-write lock object referenced by rwlock and release any resources used by the lock.
+       */
+      virtual ~write_lock ();
+
+  };
+
+  /** A read/write lock.
+   *
+   * <pre><code>
+   * ...
+   * pthread::read_write_lock _rwlock;
+   *
+   * {
+   *   // get a read lock
+   *   pthread::lock_guard<pthread::read_lock> lock(_rwlck);
+   *   ...
+   * } // lock_guard unlock lock here
+   *
+   * {
+   *   // get write lock
+   *   pthread::lock_guard<pthread::write_lock> lock(_rwlck);
+   *   ...
+   * } // lock_guard unlock lock here
+   *
+   * </code></pre>
+   *
+   */
+  typedef write_lock read_write_lock;
+  
+  /** @} */
+} // namespace pthread
+
+#endif /* pthread_read_write_lock_H */

include/pthread/sync_queue.hpp

@@ -80,12 +80,24 @@ namespace pthread {
       }
 
       /** @return current number of elements in the queue */
+#if __cplusplus < 201103L
+      size_t size() const {
+        // we use read/write locks when std::atomic is not available
+        pthread::lock_guard<pthread::read_lock> lck(_rwlock);
+#else
       size_t size() const {
+#endif
         return _items.size();
       }
 
       /** @return maximun number of items that can be put in the queue */
+#if __cplusplus < 201103L
+      size_t max_size() {
+        // we use read/write locks when std::atomic is not available
+        pthread::lock_guard<pthread::read_lock> lck(_rwlock);
+#else
       size_t max_size() const {
+#endif
         return _max_size ;
       }
 
@@ -96,7 +108,8 @@ namespace pthread {
       void set_max_size( size_t ms ){
         if (ms > 0){
 #if __cplusplus < 201103L
-          pthread::lock_guard<pthread::mutex> lck(_mutex);
+          // we use read/write locks when std::atomic is not available
+          pthread::lock_guard<pthread::write_lock> lck(_rwlock);
 #endif
           _max_size = ms;
         }else{
@@ -124,6 +137,7 @@ namespace pthread {
       pthread::condition_variable _not_full_cv;
       std::list<T>                _items ;
 #if __cplusplus < 201103L
+      pthread::read_write_lock    _rwlock;
       int                         _max_size ;
 #else
       std::atomic<int>            _max_size ;

src/exceptions.cpp

@@ -47,6 +47,11 @@ namespace pthread {
   mutex_exception::mutex_exception( const std::string &message, const int pthread_error): pthread_exception(message, pthread_error) {
   };
 
+  // read_write_lock exception -----------------------------
+  //
+  read_write_lock_exception::read_write_lock_exception( const std::string &message, const int pthread_error): pthread_exception(message, pthread_error) {
+  };
+    
   // condition_variable_exception -----------------------------
   //
   condition_variable_exception::condition_variable_exception( const std::string &message, const int pthread_error): pthread_exception(message, pthread_error){

src/read_write_lock.cpp

@@ -0,0 +1,66 @@
+
+#include "pthread/read_write_lock.hpp"
+
+
+namespace pthread {
+  
+  void write_lock::lock (){
+    int ret = pthread_rwlock_wrlock(&_rwlock);
+    if ( ret != 0 ){
+      throw read_write_lock_exception("Try get write lock failed.", ret);
+    };
+  }
+  
+  void write_lock::try_lock (){
+    int ret = pthread_rwlock_trywrlock(&_rwlock);
+    if ( ret != 0 ){
+      throw read_write_lock_exception("Try get write lock failed.", ret);
+    };
+  }
+
+  write_lock::write_lock (){//:read_lock(){
+    // intentional
+    // the read/write lock is created by the base class read_lock
+  }
+
+  write_lock::~write_lock(){
+    // intentional... base class is in charge of freeing allocated ressources
+  }
+
+  // read_lock -----------------------------
+  //
+  void read_lock::lock (){
+    int ret = pthread_rwlock_rdlock(&_rwlock);
+    if ( ret != 0 ){
+      throw read_write_lock_exception("Try get read lock failed.", ret);
+    };
+  }
+  
+  void read_lock::try_lock (){
+    int ret = pthread_rwlock_tryrdlock(&_rwlock);
+    if ( ret != 0 ){
+      throw read_write_lock_exception("Try get read lock failed.", ret);
+    };
+  }
+  
+  void read_lock::unlock (){
+    int ret = pthread_rwlock_unlock(&_rwlock);
+    if ( ret != 0 ){
+      throw read_write_lock_exception("failed to unlock read/read lock.", ret);
+    };
+  }
+
+  read_lock::read_lock (){
+    int ret = pthread_rwlock_init(&_rwlock, NULL);
+    if ( ret != 0 ){
+      throw read_write_lock_exception("Failed to init read/write lock", ret);
+    };
+  }
+
+  read_lock::~read_lock (){
+    pthread_rwlock_destroy(&_rwlock);
+  }
+
+  
+  /** @} */
+} // namespace pthread

tests/Makefile.in

@@ -31,15 +31,16 @@ LDFLAGS=@LDFLAGS@
 LIBS=@LIBS@
 
 OBJECTS=@OBJECTS@
-TARGETS=synchronized_queue_tests without-cpp11-pthread-tests exceptions-tests
+TARGETS=@TESTS@
 
 all:${TARGETS}
 
-clean: globber
-
-globber:
-	${RM} *.o core core.* *.a *.out
+clean: 
+	${RM} *.o
 	${RM} ${TARGETS}
+
+globber: clean
+	${RM} core core.* *.a *.out
 	$(RM) *unc-backup*~ *unc-backup*~
 	$(RM) ULOG*
 

tests/configure

@@ -624,6 +624,7 @@ ac_includes_default="\
 
 ac_subst_vars='LTLIBOBJS
 LIBOBJS
+TESTS
 OBJECTS
 BITS
 EGREP
@@ -3671,6 +3672,15 @@ done
 OBJECTS=$OBJECTS
 
 
+TESTS=""
+for src in *tests.cpp
+do
+  obj=`basename $src .cpp`
+  TESTS="$TESTS $obj"
+done
+TESTS=$TESTS
+
+
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for specific $CXX compiler options" >&5
 $as_echo_n "checking for specific $CXX compiler options... " >&6; }
 case "$CXX" in

tests/configure.ac

@@ -36,6 +36,14 @@ do
 done
 AC_SUBST(OBJECTS,$OBJECTS)
 
+TESTS=""
+for src in *tests.cpp
+do
+  obj=`basename $src .cpp`
+  TESTS="$TESTS $obj"
+done
+AC_SUBST(TESTS,$TESTS)
+
 AC_MSG_CHECKING([for specific $CXX compiler options])
 case "$CXX" in
   xlC_r | xlC)