"Finalize" the DWARF index in the background

After scanning the CUs, the DWARF indexer merges all the data into a
single vector, canonicalizing C++ names as it proceeds.  While not
necessarily single-threaded, this process is currently done in just
one thread, to keep memory costs lower.

However, this work is all done without reference to any data outside
of the indexes.  This patch improves the apparent performance of GDB
by moving it to the background.  All uses of the index are then made
to wait for this process to complete.

In our ongoing example, this reduces the scanning time on gdb itself
to 0.173937 (wall).  Recall that before this patch, the time was
0.668923; and psymbol reader does this in 1.598869.  That is, at the
end of this series, we see about a 10x speedup.

2 files changed, 25 insertions, 2 deletions

diff --git a/gdb/dwarf2/cooked-index.c b/gdb/dwarf2/cooked-index.c
index e56a475..784c06e 100644
--- a/gdb/dwarf2/cooked-index.c
+++ b/gdb/dwarf2/cooked-index.c
@@ -114,9 +114,13 @@ cooked_index::add (sect_offset die_offset, enum dwarf_tag tag,
 }
 
 cooked_index_vector::cooked_index_vector (vec_type &&vec)
-  : m_vector (std::move (vec))
+  : m_vector (std::move (vec)),
+    m_future (gdb::thread_pool::g_thread_pool->post_task
+	      ([this] ()
+	      {
+		finalize ();
+	      }))
 {
-  finalize ();
 }
 
 /* See cooked-index.h.  */
@@ -149,6 +153,8 @@ cooked_index_vector::get_addrmaps ()
 cooked_index_vector::range
 cooked_index_vector::find (gdb::string_view name, bool completing)
 {
+  m_future.wait ();
+
   auto lower = std::lower_bound (m_entries.begin (), m_entries.end (),
 				 name,
 				 [=] (const cooked_index_entry *entry,
diff --git a/gdb/dwarf2/cooked-index.h b/gdb/dwarf2/cooked-index.h
index 1881551..661664d 100644
--- a/gdb/dwarf2/cooked-index.h
+++ b/gdb/dwarf2/cooked-index.h
@@ -254,6 +254,17 @@ public:
   explicit cooked_index_vector (vec_type &&vec);
   DISABLE_COPY_AND_ASSIGN (cooked_index_vector);
 
+  ~cooked_index_vector ()
+  {
+    /* The 'finalize' method may be run in a different thread.  If
+       this object is destroyed before this completes, then the method
+       will end up writing to freed memory.  Waiting for this to
+       complete avoids this problem; and the cost seems ignorable
+       because creating and immediately destroying the debug info is a
+       relatively rare thing to do.  */
+    m_future.wait ();
+  }
+
   /* A simple range over part of m_entries.  */
   typedef iterator_range<std::vector<cooked_index_entry *>::iterator> range;
 
@@ -265,6 +276,7 @@ public:
   /* Return a range of all the entries.  */
   range all_entries ()
   {
+    m_future.wait ();
     return { m_entries.begin (), m_entries.end () };
   }
 
@@ -305,6 +317,11 @@ private:
 
   /* Storage for canonical names.  */
   std::vector<gdb::unique_xmalloc_ptr<char>> m_names;
+
+  /* A future that tracks when the 'finalize' method is done.  Note
+     that the 'get' method is never called on this future, only
+     'wait'.  */
+  std::future<void> m_future;
 };
 
 #endif /* GDB_DWARF2_COOKED_INDEX_H */