[llvm][lldb] Add optimal ThreadPool concurrency

[dmantipov]

Summary

Add an optimal thread strategy to execute specified amount of tasks. This strategy should prevent us from creating too many threads if we occasionaly have an unexpectedly small amount of tasks.

[dmantipov]

Running on 48-core system, I was pretty surprised to see 48-threads pool when attempting to debug a toy C++ program. So here is a fix.

[labath]

This sounds like a good idea, but I'd like to get another set of eyes on the llvm part.

[aganea]

Side-note: @dmantipov Could you please use git diff -U99999 when creating patches? This allows reviewers to quickly browse through other parts of the file(s) in Phabricator. That would fix the "Context not available." message.

The patch looks like a quick win on the short term. A better fix would create threads on-the-go as work is being pushed on the queue. An even better fix would be a system-wide thread pool for all LLVM apps. But that would require more effort, especially on testing & maintenance.

LGTM.

[aganea]

@dmantipov Do you have commit access (which I can encourage you ask here if you're planning further changes) or should I commit this for you?

lldb/source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.cpp

void ManualDWARFIndex::Index() {
   };
 
   auto extract_fn = [&units_to_index, &clear_cu_dies](size_t cu_idx) {
     clear_cu_dies[cu_idx] = units_to_index[cu_idx]->ExtractDIEsScoped();
   };
 
   // Share one thread pool across operations to avoid the overhead of
   // recreating the threads.
-  llvm::ThreadPool pool;
+  llvm::ThreadPool pool(llvm::optimal_concurrency(units_to_index.size()));
 
   // Create a task runner that extracts dies for each DWARF unit in a
   // separate thread.
   // First figure out which units didn't have their DIEs already
   // parsed and remember this.  If no DIEs were parsed prior to this index
   // function call, we are going to want to clear the CU dies after we are
   // done indexing to make sure we don't pull in all DWARF dies, but we need
   // to wait until all units have been indexed in case a DIE in one

llvm/include/llvm/Support/Threading.h

#endif
   inline ThreadPoolStrategy heavyweight_hardware_concurrency(StringRef Num) {
     Optional<ThreadPoolStrategy> S =
         get_threadpool_strategy(Num, heavyweight_hardware_concurrency());
     if (S)
       return *S;
     return heavyweight_hardware_concurrency();
   }
 
-  /// Returns a default thread strategy where all available hardware ressources
+  /// Returns a default thread strategy where all available hardware resources
   /// are to be used, except for those initially excluded by an affinity mask.
   /// This function takes affinity into consideration. Returns 1 when LLVM is
   /// configured with LLVM_ENABLE_THREADS=OFF.
   inline ThreadPoolStrategy hardware_concurrency(unsigned ThreadCount = 0) {
     ThreadPoolStrategy S;
     S.ThreadsRequested = ThreadCount;
     return S;
   }
 
+  /// Returns an optimal thread strategy to execute specified amount of tasks.
+  /// This strategy should prevent us from creating too many threads if we
+  /// occasionaly have an unexpectedly small amount of tasks.
+  inline ThreadPoolStrategy optimal_concurrency(unsigned TaskCount = 0) {
+    ThreadPoolStrategy S;
+    S.Limit = true;
+    S.ThreadsRequested = TaskCount;
+    return S;
+  }
+
   /// Return the current thread id, as used in various OS system calls.
   /// Note that not all platforms guarantee that the value returned will be
   /// unique across the entire system, so portable code should not assume
   /// this.
   uint64_t get_threadid();
 
   /// Get the maximum length of a thread name on this platform.
   /// A value of 0 means there is no limit.