From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 2126) id BB3FC3949F23; Tue, 10 May 2022 14:17:51 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org BB3FC3949F23 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable From: Tom Tromey To: gdb-cvs@sourceware.org Subject: [binutils-gdb] Fix --disable-threading build X-Act-Checkin: binutils-gdb X-Git-Author: Tom Tromey X-Git-Refname: refs/heads/master X-Git-Oldrev: c7d029ea9cc566b8d3c50b08ef12d98394adf1b1 X-Git-Newrev: 20c4eb4226997c0de0a47d5d4c6c2eed21ed9af4 Message-Id: <20220510141751.BB3FC3949F23@sourceware.org> Date: Tue, 10 May 2022 14:17:51 +0000 (GMT) X-BeenThere: gdb-cvs@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gdb-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 10 May 2022 14:17:51 -0000 https://sourceware.org/git/gitweb.cgi?p=3Dbinutils-gdb.git;h=3D20c4eb422699= 7c0de0a47d5d4c6c2eed21ed9af4 commit 20c4eb4226997c0de0a47d5d4c6c2eed21ed9af4 Author: Tom Tromey Date: Mon May 9 11:48:40 2022 -0600 Fix --disable-threading build =20 PR build/29110 points out that GDB fails to build on mingw when the "win32" thread model is in use. It turns out that the Fedora cross tools using the "posix" thread model, which somehow manages to support std::future, whereas the win32 model does not. =20 While looking into this, I found that the configuring with --disable-threading will also cause a build failure. =20 This patch fixes this build by introducing a compatibility wrapper for std::future. =20 I am not able to test the win32 thread model build, but I'm going to ask the reporter to try this patch. =20 Bug: https://sourceware.org/bugzilla/show_bug.cgi?id=3D29110 Diff: --- gdb/dwarf2/cooked-index.h | 2 +- gdbsupport/parallel-for.h | 4 +-- gdbsupport/thread-pool.cc | 6 ++-- gdbsupport/thread-pool.h | 76 +++++++++++++++++++++++++++++++++++++++++++= ---- 4 files changed, 76 insertions(+), 12 deletions(-) diff --git a/gdb/dwarf2/cooked-index.h b/gdb/dwarf2/cooked-index.h index a460351612f..1d229586948 100644 --- a/gdb/dwarf2/cooked-index.h +++ b/gdb/dwarf2/cooked-index.h @@ -330,7 +330,7 @@ private: /* 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 m_future; + gdb::future m_future; }; =20 #endif /* GDB_DWARF2_COOKED_INDEX_H */ diff --git a/gdbsupport/parallel-for.h b/gdbsupport/parallel-for.h index 713ec660306..7b6891a0dcb 100644 --- a/gdbsupport/parallel-for.h +++ b/gdbsupport/parallel-for.h @@ -72,7 +72,7 @@ private: =20 /* A vector of futures coming from the tasks run in the background. */ - std::vector> m_futures; + std::vector> m_futures; }; =20 /* See the generic template. */ @@ -108,7 +108,7 @@ public: =20 private: =20 - std::vector> m_futures; + std::vector> m_futures; }; =20 } diff --git a/gdbsupport/thread-pool.cc b/gdbsupport/thread-pool.cc index 3674e910f1d..ddb76b691c1 100644 --- a/gdbsupport/thread-pool.cc +++ b/gdbsupport/thread-pool.cc @@ -192,12 +192,13 @@ thread_pool::set_thread_count (size_t num_threads) #endif /* CXX_STD_THREAD */ } =20 +#if CXX_STD_THREAD + void thread_pool::do_post_task (std::packaged_task &&func) { std::packaged_task t (std::move (func)); =20 -#if CXX_STD_THREAD if (m_thread_count !=3D 0) { std::lock_guard guard (m_tasks_mutex); @@ -205,15 +206,12 @@ thread_pool::do_post_task (std::packaged_task &&func) m_tasks_cv.notify_one (); } else -#endif { /* Just execute it now. */ t (); } } =20 -#if CXX_STD_THREAD - void thread_pool::thread_function () { diff --git a/gdbsupport/thread-pool.h b/gdbsupport/thread-pool.h index 5e203fd896c..4db35bab957 100644 --- a/gdbsupport/thread-pool.h +++ b/gdbsupport/thread-pool.h @@ -27,13 +27,70 @@ #include #include #include -#endif #include +#endif #include "gdbsupport/gdb_optional.h" =20 namespace gdb { =20 +#if CXX_STD_THREAD + +/* Simply use the standard future. */ +template +using future =3D std::future; + +#else /* CXX_STD_THREAD */ + +/* A compatibility wrapper for std::future. Once and + are available in all GCC builds -- should that ever happen + -- this can be removed. GCC does not implement threading for + MinGW, see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=3D93687. + + Meanwhile, in this mode, there are no threads. Tasks submitted to + the thread pool are invoked immediately and their result is stored + here. The base template here simply wraps a T and provides some + std::future compatibility methods. The provided methods are chosen + based on what GDB needs presently. */ + +template +class future +{ +public: + + explicit future (T value) + : m_value (std::move (value)) + { + } + + future () =3D default; + future (future &&other) =3D default; + future (const future &other) =3D delete; + future &operator=3D (future &&other) =3D default; + future &operator=3D (const future &other) =3D delete; + + void wait () const { } + + T get () { return std::move (m_value); } + +private: + + T m_value; +}; + +/* A specialization for void. */ + +template<> +class future +{ +public: + void wait () const { } + void get () { } +}; + +#endif /* CXX_STD_THREAD */ + + /* A thread pool. =20 There is a single global thread pool, see g_thread_pool. Tasks can @@ -64,23 +121,32 @@ public: =20 /* Post a task to the thread pool. A future is returned, which can be used to wait for the result. */ - std::future post_task (std::function &&func) + future post_task (std::function &&func) { +#if CXX_STD_THREAD std::packaged_task task (std::move (func)); - std::future result =3D task.get_future (); + future result =3D task.get_future (); do_post_task (std::packaged_task (std::move (task))); return result; +#else + func (); + return {}; +#endif /* CXX_STD_THREAD */ } =20 /* Post a task to the thread pool. A future is returned, which can be used to wait for the result. */ template - std::future post_task (std::function &&func) + future post_task (std::function &&func) { +#if CXX_STD_THREAD std::packaged_task task (std::move (func)); - std::future result =3D task.get_future (); + future result =3D task.get_future (); do_post_task (std::packaged_task (std::move (task))); return result; +#else + return future (func ()); +#endif /* CXX_STD_THREAD */ } =20 private: