From: Tom Tromey <tom@tromey.com>
Date: Thu, 31 Mar 2022 02:19:54 +0000 (-0600)
Subject: Allow thread-pool.h to work without threads
X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=0981fe1017a8111aa6544ff52bcbbc80eec6b3c0;p=binutils-gdb.git

Allow thread-pool.h to work without threads

thread-pool.h requires CXX_STD_THREAD in order to even be included.
However, there's no deep reason for this, and during review we found
that one patch in the new DWARF indexer series unconditionally
requires the thread pool.

Because the thread pool already allows a task to be run in the calling
thread (for example if it is configured to have no threads in the
pool), it seemed straightforward to make this code ok to use when host
threads aren't available at all.

This patch implements this idea.  I built it on a thread-less host
(mingw, before my recent configure patch) and verified that the result
builds.

After the thread-pool change, parallel-for.h no longer needs any
CXX_STD_THREAD checks at all, so this patch removes these as well.
---

diff --git a/gdb/maint.c b/gdb/maint.c
index 3f3dad5bd79..60e183efdd1 100644
--- a/gdb/maint.c
+++ b/gdb/maint.c
@@ -41,16 +41,13 @@
 #include "maint.h"
 #include "gdbsupport/selftest.h"
 #include "inferior.h"
+#include "gdbsupport/thread-pool.h"
 
 #include "cli/cli-decode.h"
 #include "cli/cli-utils.h"
 #include "cli/cli-setshow.h"
 #include "cli/cli-cmds.h"
 
-#if CXX_STD_THREAD
-#include "gdbsupport/thread-pool.h"
-#endif
-
 static void maintenance_do_deprecate (const char *, int);
 
 #ifndef _WIN32
diff --git a/gdbsupport/parallel-for.h b/gdbsupport/parallel-for.h
index ca03094bf12..915814e485e 100644
--- a/gdbsupport/parallel-for.h
+++ b/gdbsupport/parallel-for.h
@@ -21,10 +21,7 @@
 #define GDBSUPPORT_PARALLEL_FOR_H
 
 #include <algorithm>
-#if CXX_STD_THREAD
-#include <thread>
 #include "gdbsupport/thread-pool.h"
-#endif
 
 namespace gdb
 {
@@ -41,7 +38,6 @@ template<class RandomIt, class RangeFunction>
 void
 parallel_for_each (RandomIt first, RandomIt last, RangeFunction callback)
 {
-#if CXX_STD_THREAD
   /* So we can use a local array below.  */
   const size_t local_max = 16;
   size_t n_threads = std::min (thread_pool::g_thread_pool->thread_count (),
@@ -70,15 +66,12 @@ parallel_for_each (RandomIt first, RandomIt last, RangeFunction callback)
 	  first = end;
 	}
     }
-#endif /* CXX_STD_THREAD */
 
   /* Process all the remaining elements in the main thread.  */
   callback (first, last);
 
-#if CXX_STD_THREAD
   for (int i = 0; i < n_actual_threads; ++i)
     futures[i].wait ();
-#endif /* CXX_STD_THREAD */
 }
 
 }
diff --git a/gdbsupport/thread-pool.cc b/gdbsupport/thread-pool.cc
index ce19ef23af5..7d446952cc7 100644
--- a/gdbsupport/thread-pool.cc
+++ b/gdbsupport/thread-pool.cc
@@ -18,10 +18,10 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "common-defs.h"
+#include "gdbsupport/thread-pool.h"
 
 #if CXX_STD_THREAD
 
-#include "gdbsupport/thread-pool.h"
 #include "gdbsupport/alt-stack.h"
 #include "gdbsupport/block-signals.h"
 #include <algorithm>
@@ -67,6 +67,7 @@ set_thread_name (int (*set_name) (const char *), const char *name)
 }
 
 #endif	/* USE_PTHREAD_SETNAME_NP */
+#endif /* CXX_STD_THREAD */
 
 namespace gdb
 {
@@ -93,6 +94,7 @@ thread_pool::~thread_pool ()
 void
 thread_pool::set_thread_count (size_t num_threads)
 {
+#if CXX_STD_THREAD
   std::lock_guard<std::mutex> guard (m_tasks_mutex);
 
   /* If the new size is larger, start some new threads.  */
@@ -127,6 +129,9 @@ thread_pool::set_thread_count (size_t num_threads)
     }
 
   m_thread_count = num_threads;
+#else
+  /* No threads available, simply ignore the request.  */
+#endif /* CXX_STD_THREAD */
 }
 
 std::future<void>
@@ -135,20 +140,24 @@ thread_pool::post_task (std::function<void ()> &&func)
   std::packaged_task<void ()> t (std::move (func));
   std::future<void> f = t.get_future ();
 
-  if (m_thread_count == 0)
-    {
-      /* Just execute it now.  */
-      t ();
-    }
-  else
+#if CXX_STD_THREAD
+  if (m_thread_count != 0)
     {
       std::lock_guard<std::mutex> guard (m_tasks_mutex);
       m_tasks.emplace (std::move (t));
       m_tasks_cv.notify_one ();
     }
+  else
+#endif
+    {
+      /* Just execute it now.  */
+      t ();
+    }
   return f;
 }
 
+#if CXX_STD_THREAD
+
 void
 thread_pool::thread_function ()
 {
@@ -182,6 +191,6 @@ thread_pool::thread_function ()
     }
 }
 
-}
-
 #endif /* CXX_STD_THREAD */
+
+} /* namespace gdb */
diff --git a/gdbsupport/thread-pool.h b/gdbsupport/thread-pool.h
index 68210664525..2672e4d739a 100644
--- a/gdbsupport/thread-pool.h
+++ b/gdbsupport/thread-pool.h
@@ -21,11 +21,13 @@
 #define GDBSUPPORT_THREAD_POOL_H
 
 #include <queue>
-#include <thread>
 #include <vector>
 #include <functional>
+#if CXX_STD_THREAD
+#include <thread>
 #include <mutex>
 #include <condition_variable>
+#endif
 #include <future>
 #include "gdbsupport/gdb_optional.h"
 
@@ -53,7 +55,11 @@ public:
   /* Return the number of executing threads.  */
   size_t thread_count () const
   {
+#if CXX_STD_THREAD
     return m_thread_count;
+#else
+    return 0;
+#endif
   }
 
   /* Post a task to the thread pool.  A future is returned, which can
@@ -64,6 +70,7 @@ private:
 
   thread_pool () = default;
 
+#if CXX_STD_THREAD
   /* The callback for each worker thread.  */
   void thread_function ();
 
@@ -83,6 +90,7 @@ private:
      between the main thread and the worker threads.  */
   std::condition_variable m_tasks_cv;
   std::mutex m_tasks_mutex;
+#endif /* CXX_STD_THREAD */
 };
 
 }