From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from omta036.useast.a.cloudfilter.net (omta036.useast.a.cloudfilter.net [44.202.169.35]) by sourceware.org (Postfix) with ESMTPS id 0AB10385800D for ; Sun, 10 Dec 2023 21:41:24 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 0AB10385800D Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=tromey.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=tromey.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 0AB10385800D Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=44.202.169.35 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1702244489; cv=none; b=S3vefePaDOuvE2N5v2JKrWXEWcKE2OoH9WP53ny72/iPhrJG+O8Z7DxWmq/Th2vR0rr+Rn3u83UtKYCk3vdFEuEhfIpfCnu264M8GKvRQZK4DCVqY7LfwgMX8O9McxKdgv/M2hfA22cqpojDqi6BM/6W4ly1BuoS05vQ6xlZNSE= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1702244489; c=relaxed/simple; bh=P/t8XfKh912DNDqh4tIa87iZo12XEQloyNNSt6J3lgs=; h=DKIM-Signature:From:Date:Subject:MIME-Version:Message-Id:To; b=E2+Cqa2fJ0p7UVJbhLXNpxouSMTgl0D6vikVAvVnWSEJX7NyaJ1sa1dqAQbZHCzG5YSZ047WxR/aEXncAc01DOiKGRr8YLS4nADwF5iUZpT5vQC8dpeW2W4/BZR05hQuhgHk4BsJdNq4BxrYNY0lYiiLWQMdS1aOQUHp8wjnIEY= ARC-Authentication-Results: i=1; server2.sourceware.org Received: from eig-obgw-5002a.ext.cloudfilter.net ([10.0.29.215]) by cmsmtp with ESMTPS id CLKCrw4iqgpyECRYBr9E0a; Sun, 10 Dec 2023 21:41:23 +0000 Received: from box5379.bluehost.com ([162.241.216.53]) by cmsmtp with ESMTPS id CRYAr8JacRQmiCRYBrUMU1; Sun, 10 Dec 2023 21:41:23 +0000 X-Authority-Analysis: v=2.4 cv=CdcbWZnl c=1 sm=1 tr=0 ts=65763083 a=ApxJNpeYhEAb1aAlGBBbmA==:117 a=ApxJNpeYhEAb1aAlGBBbmA==:17 a=OWjo9vPv0XrRhIrVQ50Ab3nP57M=:19 a=dLZJa+xiwSxG16/P+YVxDGlgEgI=:19 a=IkcTkHD0fZMA:10 a=e2cXIFwxEfEA:10 a=Qbun_eYptAEA:10 a=8SexAYW74Qp0OzhZtVkA:9 a=QEXdDO2ut3YA:10 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=tromey.com; s=default; h=To:In-Reply-To:References:Message-Id:Content-Transfer-Encoding: Content-Type:MIME-Version:Subject:Date:From:Sender:Reply-To:Cc:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Id:List-Help:List-Unsubscribe:List-Subscribe: List-Post:List-Owner:List-Archive; bh=W5vD5MIQhWlxQDlFJQZsNP5WeVlnO1KHeewlLlBhUJw=; b=Tvmx/53X6tAWRm2BZpD2wWI1KU Mimngw1CIBy0Q3k7F17zOx+ajg8E/66841DsSdDatDauTguOwkm6hM4bu+PXTP/Pec2ExG4Obc4t1 NxWPkjo1axrV4MJLDlleTo05R; Received: from [198.59.47.65] (port=52450 helo=[192.168.131.83]) by box5379.bluehost.com with esmtpsa (TLS1.2) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.96.2) (envelope-from ) id 1rCRYA-000SHj-2H for gdb-patches@sourceware.org; Sun, 10 Dec 2023 14:41:22 -0700 From: Tom Tromey Date: Sun, 10 Dec 2023 14:41:27 -0700 Subject: [PATCH v4 19/19] Back out some parallel_for_each features MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: 7bit Message-Id: <20231210-t-bg-dwarf-reading-v4-19-b978c32fd12f@tromey.com> References: <20231210-t-bg-dwarf-reading-v4-0-b978c32fd12f@tromey.com> In-Reply-To: <20231210-t-bg-dwarf-reading-v4-0-b978c32fd12f@tromey.com> To: gdb-patches@sourceware.org X-Mailer: b4 0.12.4 X-AntiAbuse: This header was added to track abuse, please include it with any abuse report X-AntiAbuse: Primary Hostname - box5379.bluehost.com X-AntiAbuse: Original Domain - sourceware.org X-AntiAbuse: Originator/Caller UID/GID - [47 12] / [47 12] X-AntiAbuse: Sender Address Domain - tromey.com X-BWhitelist: no X-Source-IP: 198.59.47.65 X-Source-L: No X-Exim-ID: 1rCRYA-000SHj-2H X-Source: X-Source-Args: X-Source-Dir: X-Source-Sender: ([192.168.131.83]) [198.59.47.65]:52450 X-Source-Auth: tom+tromey.com X-Email-Count: 22 X-Org: HG=bhshared;ORG=bluehost; X-Source-Cap: ZWx5bnJvYmk7ZWx5bnJvYmk7Ym94NTM3OS5ibHVlaG9zdC5jb20= X-Local-Domain: yes X-CMAE-Envelope: MS4xfDNupnvmtCivvrn0eO3WY1mbgkfeXJEHldMmS4toUiMilCT9dQSlgmLs1Nrb8x6iLYPjRuWdHknvm4xuWGeo7KFNIX9pFtDJ+PDUIraKG1+Qyf8uoQmj ZN2PlR9t2lAksa6D8tFhp92/613XEojlBK2vO/FAJ5s6T2VKn5vFafCkPJ/49YtjCV7kEf/ydXOTpyvLVlyq5m4IJH1N37+3QJE= X-Spam-Status: No, score=-3024.2 required=5.0 tests=BAYES_00,DKIM_SIGNED,DKIM_VALID,GIT_PATCH_0,JMQ_SPF_NEUTRAL,RCVD_IN_DNSWL_NONE,RCVD_IN_MSPIKE_H2,SPF_HELO_NONE,SPF_PASS,TXREP,T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: Now that the DWARF reader does not use parallel_for_each, we can remove some of the features that were added just for it: return values and task sizing. The thread_pool typed tasks feature could also be removed, but I haven't done so here. This one seemed less intrusive and perhaps more likely to be needed at some point. --- gdb/unittests/parallel-for-selftests.c | 47 ------- gdbsupport/parallel-for.h | 234 +++++---------------------------- 2 files changed, 30 insertions(+), 251 deletions(-) diff --git a/gdb/unittests/parallel-for-selftests.c b/gdb/unittests/parallel-for-selftests.c index 63e9512ea18..a957b2daa3e 100644 --- a/gdb/unittests/parallel-for-selftests.c +++ b/gdb/unittests/parallel-for-selftests.c @@ -120,34 +120,6 @@ TEST (int n_threads) }); SELF_CHECK (counter == 0); - auto task_size_max_ = [] (int iter) - { - return (size_t)SIZE_MAX; - }; - auto task_size_max = gdb::make_function_view (task_size_max_); - - counter = 0; - FOR_EACH (1, 0, NUMBER, - [&] (int start, int end) - { - counter += end - start; - }, task_size_max); - SELF_CHECK (counter == NUMBER); - - auto task_size_one_ = [] (int iter) - { - return (size_t)1; - }; - auto task_size_one = gdb::make_function_view (task_size_one_); - - counter = 0; - FOR_EACH (1, 0, NUMBER, - [&] (int start, int end) - { - counter += end - start; - }, task_size_one); - SELF_CHECK (counter == NUMBER); - #undef NUMBER /* Check that if there are fewer tasks than threads, then we won't @@ -169,25 +141,6 @@ TEST (int n_threads) { return entry != nullptr; })); - - /* The same but using the task size parameter. */ - intresults.clear (); - any_empty_tasks = false; - FOR_EACH (1, 0, 1, - [&] (int start, int end) - { - if (start == end) - any_empty_tasks = true; - return std::make_unique (end - start); - }, - task_size_one); - SELF_CHECK (!any_empty_tasks); - SELF_CHECK (std::all_of (intresults.begin (), - intresults.end (), - [] (const std::unique_ptr &entry) - { - return entry != nullptr; - })); } #endif /* FOR_EACH */ diff --git a/gdbsupport/parallel-for.h b/gdbsupport/parallel-for.h index ee7bfd948e2..1825dbc69b1 100644 --- a/gdbsupport/parallel-for.h +++ b/gdbsupport/parallel-for.h @@ -28,104 +28,6 @@ namespace gdb { -namespace detail -{ - -/* This is a helper class that is used to accumulate results for - parallel_for. There is a specialization for 'void', below. */ -template -struct par_for_accumulator -{ -public: - - explicit par_for_accumulator (size_t n_threads) - : m_futures (n_threads) - { - } - - /* The result type that is accumulated. */ - typedef std::vector result_type; - - /* Post the Ith task to a background thread, and store a future for - later. */ - void post (size_t i, std::function task) - { - m_futures[i] - = gdb::thread_pool::g_thread_pool->post_task (std::move (task)); - } - - /* Invoke TASK in the current thread, then compute all the results - from all background tasks and put them into a result vector, - which is returned. */ - result_type finish (gdb::function_view task) - { - result_type result (m_futures.size () + 1); - - result.back () = task (); - - for (size_t i = 0; i < m_futures.size (); ++i) - result[i] = m_futures[i].get (); - - return result; - } - - /* Resize the results to N. */ - void resize (size_t n) - { - m_futures.resize (n); - } - -private: - - /* A vector of futures coming from the tasks run in the - background. */ - std::vector> m_futures; -}; - -/* See the generic template. */ -template<> -struct par_for_accumulator -{ -public: - - explicit par_for_accumulator (size_t n_threads) - : m_futures (n_threads) - { - } - - /* This specialization does not compute results. */ - typedef void result_type; - - void post (size_t i, std::function task) - { - m_futures[i] - = gdb::thread_pool::g_thread_pool->post_task (std::move (task)); - } - - result_type finish (gdb::function_view task) - { - task (); - - for (auto &future : m_futures) - { - /* Use 'get' and not 'wait', to propagate any exception. */ - future.get (); - } - } - - /* Resize the results to N. */ - void resize (size_t n) - { - m_futures.resize (n); - } - -private: - - std::vector> m_futures; -}; - -} - /* A very simple "parallel for". This splits the range of iterators into subranges, and then passes each subrange to the callback. The work may or may not be done in separate threads. @@ -136,23 +38,13 @@ struct par_for_accumulator The parameter N says how batching ought to be done -- there will be at least N elements processed per thread. Setting N to 0 is not - allowed. - - If the function returns a non-void type, then a vector of the - results is returned. The size of the resulting vector depends on - the number of threads that were used. */ + allowed. */ template -typename gdb::detail::par_for_accumulator< - typename std::invoke_result::type - >::result_type +void parallel_for_each (unsigned n, RandomIt first, RandomIt last, - RangeFunction callback, - gdb::function_view task_size = nullptr) + RangeFunction callback) { - using result_type - = typename std::invoke_result::type; - /* If enabled, print debug info about how the work is distributed across the threads. */ const bool parallel_for_each_debug = false; @@ -162,87 +54,37 @@ parallel_for_each (unsigned n, RandomIt first, RandomIt last, size_t n_elements = last - first; size_t elts_per_thread = 0; size_t elts_left_over = 0; - size_t total_size = 0; - size_t size_per_thread = 0; - size_t max_element_size = n_elements == 0 ? 1 : SIZE_MAX / n_elements; if (n_threads > 1) { - if (task_size != nullptr) - { - gdb_assert (n == 1); - for (RandomIt i = first; i != last; ++i) - { - size_t element_size = task_size (i); - gdb_assert (element_size > 0); - if (element_size > max_element_size) - /* We could start scaling here, but that doesn't seem to be - worth the effort. */ - element_size = max_element_size; - size_t prev_total_size = total_size; - total_size += element_size; - /* Check for overflow. */ - gdb_assert (prev_total_size < total_size); - } - size_per_thread = total_size / n_threads; - } - else - { - /* Require that there should be at least N elements in a - thread. */ - gdb_assert (n > 0); - if (n_elements / n_threads < n) - n_threads = std::max (n_elements / n, (size_t) 1); - elts_per_thread = n_elements / n_threads; - elts_left_over = n_elements % n_threads; - /* n_elements == n_threads * elts_per_thread + elts_left_over. */ - } + /* Require that there should be at least N elements in a + thread. */ + gdb_assert (n > 0); + if (n_elements / n_threads < n) + n_threads = std::max (n_elements / n, (size_t) 1); + elts_per_thread = n_elements / n_threads; + elts_left_over = n_elements % n_threads; + /* n_elements == n_threads * elts_per_thread + elts_left_over. */ } size_t count = n_threads == 0 ? 0 : n_threads - 1; - gdb::detail::par_for_accumulator results (count); + std::vector> results; if (parallel_for_each_debug) { debug_printf (_("Parallel for: n_elements: %zu\n"), n_elements); - if (task_size != nullptr) - { - debug_printf (_("Parallel for: total_size: %zu\n"), total_size); - debug_printf (_("Parallel for: size_per_thread: %zu\n"), size_per_thread); - } - else - { - debug_printf (_("Parallel for: minimum elements per thread: %u\n"), n); - debug_printf (_("Parallel for: elts_per_thread: %zu\n"), elts_per_thread); - } + debug_printf (_("Parallel for: minimum elements per thread: %u\n"), n); + debug_printf (_("Parallel for: elts_per_thread: %zu\n"), elts_per_thread); } - size_t remaining_size = total_size; for (int i = 0; i < count; ++i) { RandomIt end; - size_t chunk_size = 0; - if (task_size == nullptr) - { - end = first + elts_per_thread; - if (i < elts_left_over) - /* Distribute the leftovers over the worker threads, to avoid having - to handle all of them in a single thread. */ - end++; - } - else - { - RandomIt j; - for (j = first; j < last && chunk_size < size_per_thread; ++j) - { - size_t element_size = task_size (j); - if (element_size > max_element_size) - element_size = max_element_size; - chunk_size += element_size; - } - end = j; - remaining_size -= chunk_size; - } + end = first + elts_per_thread; + if (i < elts_left_over) + /* Distribute the leftovers over the worker threads, to avoid having + to handle all of them in a single thread. */ + end++; /* This case means we don't have enough elements to really distribute them. Rather than ever submit a task that does @@ -257,7 +99,6 @@ parallel_for_each (unsigned n, RandomIt first, RandomIt last, the result list here. This avoids submitting empty tasks to the thread pool. */ count = i; - results.resize (count); break; } @@ -265,12 +106,12 @@ parallel_for_each (unsigned n, RandomIt first, RandomIt last, { debug_printf (_("Parallel for: elements on worker thread %i\t: %zu"), i, (size_t)(end - first)); - if (task_size != nullptr) - debug_printf (_("\t(size: %zu)"), chunk_size); debug_printf (_("\n")); } - results.post (i, [=] () - { return callback (first, end); }); + results.push_back (gdb::thread_pool::g_thread_pool->post_task ([=] () + { + return callback (first, end); + })); first = end; } @@ -278,8 +119,6 @@ parallel_for_each (unsigned n, RandomIt first, RandomIt last, if (parallel_for_each_debug) { debug_printf (_("Parallel for: elements on worker thread %i\t: 0"), i); - if (task_size != nullptr) - debug_printf (_("\t(size: 0)")); debug_printf (_("\n")); } @@ -288,14 +127,12 @@ parallel_for_each (unsigned n, RandomIt first, RandomIt last, { debug_printf (_("Parallel for: elements on main thread\t\t: %zu"), (size_t)(last - first)); - if (task_size != nullptr) - debug_printf (_("\t(size: %zu)"), remaining_size); debug_printf (_("\n")); } - return results.finish ([=] () - { - return callback (first, last); - }); + callback (first, last); + + for (auto &fut : results) + fut.get (); } /* A sequential drop-in replacement of parallel_for_each. This can be useful @@ -303,22 +140,11 @@ parallel_for_each (unsigned n, RandomIt first, RandomIt last, multi-threading in a fine-grained way. */ template -typename gdb::detail::par_for_accumulator< - typename std::invoke_result::type - >::result_type +void sequential_for_each (unsigned n, RandomIt first, RandomIt last, - RangeFunction callback, - gdb::function_view task_size = nullptr) + RangeFunction callback) { - using result_type = typename std::invoke_result::type; - - gdb::detail::par_for_accumulator results (0); - - /* Process all the remaining elements in the main thread. */ - return results.finish ([=] () - { - return callback (first, last); - }); + callback (first, last); } } -- 2.43.0