Merge John's changes and update test suite.

.gitmodules

@@ -1,3 +1,6 @@
 [submodule "cmake/Modules/FindTBB"]
 	path = cmake/Modules/FindTBB
 	url = https://github.com/justusc/FindTBB
+[submodule "testsuite"]
+	path = testsuite
+	url = https://github.com/dyninst/testsuite

cmake/endian.cmake

@@ -0,0 +1,8 @@
+INCLUDE(TestBigEndian)
+
+TEST_BIG_ENDIAN(BIGENDIAN)
+if(${BIGENDIAN})
+ ADD_DEFINITIONS(-DDYNINST_BIG_ENDIAN)
+else()
+ ADD_DEFINITIONS(-DDYNINST_LITTLE_ENDIAN)
+endif(${BIGENDIAN})

cmake/shared.cmake

@@ -94,6 +94,7 @@ include (${DYNINST_ROOT}/cmake/visibility.cmake)
 include (${DYNINST_ROOT}/cmake/warnings.cmake)
 include (${DYNINST_ROOT}/cmake/options.cmake)
 include (${DYNINST_ROOT}/cmake/optimization.cmake)
+include (${DYNINST_ROOT}/cmake/endian.cmake)
 
 # Check for cotire-gcc compatibility
 IF(CMAKE_COMPILER_IS_GNUCC)

common/CMakeLists.txt

@@ -15,6 +15,9 @@ endif()
 
 
 set (SRC_LIST
+    src/mcs-lock.C
+    src/pfq-rwlock.C
+    src/race-detector-annotations.C
     src/string-regex.C
     src/Timer.C 
     src/Types.C 

common/h/IBSTree-fast.h

@@ -42,18 +42,17 @@
 #include <boost/mpl/inherit.hpp>
 #include <iostream>
 
-#include <boost/thread/locks.hpp>
-#include <boost/thread/lockable_adapter.hpp>
-#include <boost/thread/shared_mutex.hpp>
-#include <boost/thread/shared_lock_guard.hpp>
-
+#include "pfq-rwlock.h"
 
 namespace Dyninst
 {
 
     template <typename ITYPE >
-    class IBSTree_fast : public boost::upgrade_lockable_adapter<boost::upgrade_mutex>
-    {
+    class IBSTree_fast {
+    private:
+        // reader-writer lock to coordinate concurrent operations
+        mutable pfq_rwlock_t rwlock;
+
     public:
         typedef typename ITYPE::type interval_type;
 
@@ -69,20 +68,25 @@ namespace Dyninst
 
         IBSTree_fast()
         {
+            pfq_rwlock_init(rwlock);
         }
         ~IBSTree_fast()
         {
             //std::cerr << "Fast interval tree had " << unique_intervals.size() << " unique intervals and " << overlapping_intervals.size() << " overlapping" << std::endl;
         }
         int size() const
         {
-            boost::shared_lock_guard<const IBSTree_fast<ITYPE> > g(*this);
-            return overlapping_intervals.size() + unique_intervals.size();
+            pfq_rwlock_read_lock(rwlock);
+            int result = overlapping_intervals.size() + unique_intervals.size();
+            pfq_rwlock_read_unlock(rwlock);
+	    return result;
         }
         bool empty() const
         {
-            boost::shared_lock_guard<const IBSTree_fast<ITYPE> > g(*this);
-            return unique_intervals.empty() && overlapping_intervals.empty();
+            pfq_rwlock_read_lock(rwlock);
+            bool result = unique_intervals.empty() && overlapping_intervals.empty();
+            pfq_rwlock_read_unlock(rwlock);
+	    return result;
         }
         void insert(ITYPE*);
         void remove(ITYPE*);
@@ -93,10 +97,11 @@ namespace Dyninst
         void clear();
         friend std::ostream& operator<<(std::ostream& stream, const IBSTree_fast<ITYPE>& tree)
         {
-            boost::shared_lock_guard<const IBSTree_fast<ITYPE> > g(tree);
+            pfq_rwlock_read_lock(tree.rwlock);
             std::copy(tree.unique_intervals.begin(), tree.unique_intervals.end(),
                       std::ostream_iterator<typename Dyninst::IBSTree_fast<ITYPE>::interval_set::value_type>(stream, "\n"));
             stream << tree.overlapping_intervals;
+            pfq_rwlock_read_unlock(tree.rwlock);
             return stream;
         }
 
@@ -105,64 +110,78 @@ namespace Dyninst
     template <class ITYPE>
     void IBSTree_fast<ITYPE>::insert(ITYPE* entry)
     {
-        boost::lock_guard<IBSTree_fast<ITYPE> > u(*this);
+        pfq_rwlock_node_t me;
+        pfq_rwlock_write_lock(rwlock, me);
+
+        do {
         // find in overlapping first
         std::set<ITYPE*> dummy;
         if(overlapping_intervals.find(entry, dummy))
         {
             overlapping_intervals.insert(entry);
-            return;
-        }
-        typename interval_set::iterator lower =
-                unique_intervals.upper_bound(entry->low());
-        // lower.high first >= entry.low
-        if(lower != unique_intervals.end() && (**lower == *entry)) return;
-        typename interval_set::iterator upper = lower;
-        while(upper != unique_intervals.end() &&
-              (*upper)->low() <= entry->high())
-        {
-            overlapping_intervals.insert(*upper);
-            ++upper;
-        }
-        if(upper != lower)
-        {
-            unique_intervals.erase(lower, upper);
-            overlapping_intervals.insert(entry);
-        }
-        else
-        {
-            unique_intervals.insert(entry);
-        }
+        } else { 
+	  typename interval_set::iterator lower =
+	    unique_intervals.upper_bound(entry->low());
+	  // lower.high first >= entry.low
+	  if (lower != unique_intervals.end() && (**lower == *entry)) break;
+	  typename interval_set::iterator upper = lower;
+	  while(upper != unique_intervals.end() &&
+		(*upper)->low() <= entry->high())
+	    {
+	      overlapping_intervals.insert(*upper);
+	      ++upper;
+	    }
+	  if(upper != lower)
+	    {
+	      unique_intervals.erase(lower, upper);
+	      overlapping_intervals.insert(entry);
+	    }
+	  else
+	    {
+	      unique_intervals.insert(entry);
+	    }
+	}
+        } while(0);
+
+        pfq_rwlock_write_unlock(rwlock, me);
     }
     template <class ITYPE>
     void IBSTree_fast<ITYPE>::remove(ITYPE* entry)
     {
-        boost::lock_guard<IBSTree_fast<ITYPE> > u(*this);
+        pfq_rwlock_node_t me;
+        pfq_rwlock_write_lock(rwlock, me);
+
         overlapping_intervals.remove(entry);
         typename interval_set::iterator found = unique_intervals.find(entry->high());
         if(found != unique_intervals.end() && *found == entry) unique_intervals.erase(found);
+        pfq_rwlock_write_unlock(rwlock, me);
     }
     template<class ITYPE>
     int IBSTree_fast<ITYPE>::find(interval_type X, std::set<ITYPE*> &results) const
     {
-        boost::shared_lock_guard<const IBSTree_fast<ITYPE> > g(*this);
+      int count = 0;
+      pfq_rwlock_read_lock(rwlock);
+      do {
         int num_old_results = results.size();
 
         int num_overlapping = overlapping_intervals.find(X, results);
-        if(num_overlapping > 0) return num_overlapping;
+        if(num_overlapping > 0) { count = num_overlapping; break; }
 
         typename interval_set::const_iterator found_unique = unique_intervals.upper_bound(X);
         if(found_unique != unique_intervals.end())
         {
-            if((*found_unique)->low() > X) return 0;
+	  if((*found_unique)->low() > X) { count = 0; break; }
             results.insert(*found_unique);
         }
-        return results.size() - num_old_results;
+        count = results.size() - num_old_results;
+      } while (0);
+      pfq_rwlock_read_unlock(rwlock);
+      return count;
     }
     template <typename ITYPE>
     int IBSTree_fast<ITYPE>::find(ITYPE* I, std::set<ITYPE*>&results) const
     {
-        boost::shared_lock_guard<const IBSTree_fast<ITYPE> > g(*this);
+        pfq_rwlock_read_lock(rwlock);
         int num_old_results = results.size();
         int num_overlapping = overlapping_intervals.find(I, results);
         if(num_overlapping) return num_overlapping;
@@ -173,12 +192,14 @@ namespace Dyninst
             results.insert(*ub);
             ++ub;
         }
-        return results.size() - num_old_results;
+        int result = results.size() - num_old_results;
+        pfq_rwlock_read_unlock(rwlock);
+	return result;
     }
     template<typename ITYPE>
     void IBSTree_fast<ITYPE>::successor(interval_type X, std::set<ITYPE*>& results) const
     {
-        boost::shared_lock_guard<const IBSTree_fast<ITYPE> > g(*this);
+        pfq_rwlock_read_lock(rwlock);
         ITYPE* overlapping_ub = overlapping_intervals.successor(X);
 
         typename interval_set::const_iterator unique_ub = unique_intervals.upper_bound(X);
@@ -194,24 +215,25 @@ namespace Dyninst
         {
             results.insert(*unique_ub);
         }
+        pfq_rwlock_read_unlock(rwlock);
     }
     template <typename ITYPE>
     ITYPE* IBSTree_fast<ITYPE>::successor(interval_type X) const
     {
-        boost::shared_lock_guard<const IBSTree_fast<ITYPE> > g(*this);
         std::set<ITYPE*> tmp;
         successor(X, tmp);
         assert(tmp.size() <= 1);
         if(tmp.empty()) return NULL;
         return *tmp.begin();
-
     }
     template <typename ITYPE>
     void IBSTree_fast<ITYPE>::clear()
     {
-        boost::lock_guard<IBSTree_fast<ITYPE> > u(*this);
+        pfq_rwlock_node_t me;
+        pfq_rwlock_write_lock(rwlock, me);
         overlapping_intervals.clear();
         unique_intervals.clear();
+        pfq_rwlock_write_unlock(rwlock, me);
     }
 
 }