Use SmallPtrSet in ClusterManager

[scknight]

Summary

Based on conversations with Greg and Jim on lldb-dev, when lldb looks a a root object with many sub objects the ClusterManager can get slower and slower. This change switches the internal object list from a vector to the SmallPtrSet data type which speeds things up.

[tfiala]

Hey Scott,

Did this ever get reviewed? The change looks reasonable to me. Did you
run lldb tests against it?

-Todd

[scknight]

This did not ever get reviewed. I wasn't sure about the process after submitting the patch to phabricator. I have not run tests yet because I wasn't clear on that process either. The lldb website mentions using make to run tests but that's under the building on linux/freebsd section. Since I'm on MacOSX is it just a matter of running dotest.py? Or is there more to it than that?

[tfiala]

I'll go ahead and update the web page for how I'm run tests under MacOSX
since I recently started doing that.

Note right now MacOSX tests don't run clean at top of tree at this moment,
we're getting somewhere around 10 failed tests. I can give the patch a
check on Linux and at least confirm if no new tests break on MacOSX.

[scknight]

I did go ahead and run dotest.py this morning both before and after applying the patch and it seems to have the same 10 failures before and after like you mentioned. Another set of eyes checking the test results would be great though.

include/lldb/Utility/SharedCluster.h

 #include "lldb/Utility/SharingPtr.h"
 #include "lldb/Host/Mutex.h"
 
+#include "llvm/ADT/SmallPtrSet.h"
+
 namespace lldb_private {
 
 namespace imp

     
     ~ClusterManager ()
     {
-        size_t n_items = m_objects.size();
-        for (size_t i = 0; i < n_items; i++)
+        for (typename llvm::SmallPtrSet<T *, 16>::iterator pos = m_objects.begin(), end = m_objects.end(); pos != end; ++pos)
         {
-            delete m_objects[i];
+            T *object = *pos;
+            delete object;
         }
+
         // Decrement refcount should have been called on this ClusterManager,
         // and it should have locked the mutex, now we will unlock it before
         // we destroy it...

     void ManageObject (T *new_object)
     {
         Mutex::Locker locker (m_mutex);
-        if (!ContainsObject(new_object))
-            m_objects.push_back (new_object);
+        m_objects.insert (new_object);
     }
     
     typename lldb_private::SharingPtr<T> GetSharedPointer(T *desired_object)

         {
             Mutex::Locker locker (m_mutex);
             m_external_ref++;
-            assert (ContainsObject(desired_object));
+            assert (m_objects.count(desired_object));
         }
         return typename lldb_private::SharingPtr<T> (desired_object, new imp::shared_ptr_refcount<ClusterManager> (this));
     }
     
 private:
     
-    bool ContainsObject (const T *desired_object)
-    {
-        typename std::vector<T *>::iterator pos, end = m_objects.end();
-        pos = std::find(m_objects.begin(), end, desired_object);
-        return pos != end;
-    }
-    
     void DecrementRefCount () 
     {
         m_mutex.Lock();

     
     friend class imp::shared_ptr_refcount<ClusterManager>;
     
-    std::vector<T *> m_objects;
+    llvm::SmallPtrSet<T *, 16> m_objects;
     int m_external_ref;
     Mutex m_mutex;
 };