问题标签 [parallelism-amdahl]

这是我对英特尔 TBB 流图性能进行基准测试的尝试。这是设置：

• 一个广播节点发送continue_msg到N后继节点
  ( a broadcast_node<continue_msg>)
• 每个后继节点执行需要t几秒钟的计算。
• 串行执行时的总计算时间为Tserial = N * t
• 如果使用所有内核，理想的计算时间是Tpar(ideal) = N * t / C，其中C是内核数。
• 加速比定义为Tpar(actual) / Tserial
• 我在 16 核 PC 上使用 gcc5 测试了代码。

以下是显示加速作为单个任务（即主体）处理时间的函数的结果：

与轻量级任务（其计算时间不到 1 微秒）一样，并行代码实际上比串行代码慢。

以下是我的问题：

1 ) 这些结果是否符合英特尔 TBB 基准？
2 ) 当有数千个任务每个花费不到 1 微秒的时间时，是否有比流程图更好的范例？

我正在尝试在 python 下运行并行进程（在 ubuntu 上）。

我开始使用多处理，它适用于简单的示例。
然后出现了泡菜错误，所以我切换到悲情。我对不同的选项有点困惑，所以写了一个非常简单的基准测试代码。

我得到大约
- 0.001s 使用纯串行代码，没有并行，
- 0.100s 使用multiprocessing选项，
- 0.100s 使用pathos.multiprocessing，
- 4.470s 使用pathos.pools，
-AssertionError错误pathos.parallel

我从http://trac.mystic.cacr.caltech.edu/project/pathos/browser/pathos/examples.html复制了如何使用这些不同的选项

我知道对于这样一个简单的示例，并行处理比普通的串行代码要长。我不明白的是悲情的相对表现。

我检查了讨论，但不明白为什么pathos.pools会这么长，以及为什么会出错（不确定最后一个选项的性能如何）。

我还尝试了一个简单的平方函数，甚至pathos.multiprocessing比multiprocessing

有人可以解释这些不同选项之间的区别吗？

此外，我在远程计算机上运行该选项，运行centOS pathos.multiprocessing，性能比multiprocessing.

根据租用计算机的公司的说法，它应该像家用计算机一样工作。我知道，如果没有更多关于机器的详细信息，可能很难提供信息，但如果您对它的来源有任何想法，那将有所帮助。

我有一个具有顺序和并行变体的随机程序。该程序的本质是它的运行时间根据它的“运气”而变化很大。它通常以看似几何分布的模式在 1 秒到 2 分钟之间取值。并行变体显示出具有不同数字的类似行为。

在这种情况下，衡量并行加速的“好”方法是什么？我有可能只使用测量值的平均值/中值作为“运行时间”的代表

我将如何解释这种方法，是否有（统计/数学）更好的方法来计算加速？

编辑：感谢 user3666197，它指出了获得良好数据所必需的一些非常重要的技术细节。我已经完成了这项作业，并想澄清我的问题。

我使我的基准测试过程尽可能可靠：

• 基准测试是用种子运行的，结果是可重现的。
• 每个配置都在脚本中使用不同的种子重复多次（~400 次）

我的问题仍然存在：如何计算该程序的加速比。

我做了什么：

平均顺序运行时间约为 8.38，中位数为 4.8，这是一个很大的差异。对于 2 个线程，平均运行时间为 4.36，而中值运行时间为 2.42。如果我将顺序除以并行，我会得到 1.92（平均值）和 1.992（中值）的加速。对于 4 个线程类似：意味着：2.25 运行时间和 3.72 加速，中位数：1.12 中位数和 4.3 加速（超线性）。8 个线程存在类似的数字。

我尝试以不同的方式可视化数据。情节

直方图显示了使用各种线程的运行时间分布，右侧的箱线图也是如此。可以看出一些加速是可见的。

如果我根据种子对测量值进行配对，我会得到成对的时间：顺序时间和并行时间。我的第一个想法是通过计算回归线的斜率来计算加速，但是，回归线似乎没有正确“总结”数据并且价值有限。在右下角的图中，只显示了 4 个线程的点。

我想在 python 中实现一个在线递归并行算法。

所以每次我得到一个新的观察结果时，我都想计算一个新的系数矩阵。该矩阵上的每一行都必须并行计算。

为每个时间步创建一个新进程是否太昂贵，该进程将前一个时间步的行作为输入并计算下一个时间步的行并在计算之后将其杀死并再次创建它？

还是让进程一直运行更好？如果第二个是两者中最好的，我怎样才能恢复相同的过程但输入不同？

有什么办法吗？

也许这真的很简单，但我在理解这一点时遇到了一些问题。

我面临的挑战是从母函数内部执行子并行函数。在等待子并行函数调用的结果时，该母函数应该只运行一次。

我写了一个小例子来说明我的困境。

如果您在两者之间切换doInParallel，True那么False您可以看到问题。运行时childFunctionSerial()只motherFunction()运行一次。但是当我们使用childFunctionParallelthen运行时，motherFunction()会执行多次。两者都给出相同的结果，但我遇到的问题是motherFunction()应该只执行一次。

两个问题：

1.如何重构程序，让我们执行一次母函数，
并从它内部开始并行作业，而不运行同一个母函数的多个实例？
2.我怎样才能将第二个参数传递给jobToDoById()除了id？

我有（或实际上正在开发）一个程序（一些配对交易策略），它执行以下操作：

1. 检索位于 postgres 数据库中的较大数据（财务数据：约 100 只股票的日期时间指数和股票价格）的子集。
2. 清理数据（放弃 >30% NaN 的股票）并计算回报和指数（相对于每只股票的第一次观察）
3. 找到股票对的所有组合，计算相关性（实际上是一些类似的度量，但在这里太重要了）
4. 将相关性最高的对排名到最低或仅选择相关性 > 定义阈值的对，即 0.9
5. 检查每一对的协整，双向！并根据它们的测试值对它们进行排名
6. 选择要交易的前 n 个，即 10 对，并根据移动平均线和标准计算一些信号
7. 检索“样本外”窗口并交易股票
8. 在日志中记录每天的回报（即 5 天内）
9. 计算一些统计数据

在这 9 个步骤之后，重新开始，检索另一个训练窗口并执行分析......

我的方法是 - 如果你看到更好的东西，请更正：
1. 从程序中提取尽可能多的功能
2. 通过多个培训和交易窗口循环步骤 1-9

和我由此产生的问题（受到论坛中许多线程的启发，即如何使您的 python 代码运行得更快

• 如何确定我的代码的哪一部分可以并行运行？
• 不知何故，这对我来说似乎微不足道：应用什么技术来“重写”代码，以便它可以使用多处理？
• 也不总是很明显：将循环重写为函数，总是要查看任何特定的角度？
• numba.jit()“ ”所有功能有意义吗？
• 我应该将数据的所有格式更改为float64? 会发生什么不利情况？（目前它们是“标准”数字）
• 是否有任何清单可以让我看到何时可以对循环进行矢量化？

请为许多 - 相当概念性的 - 问题道歉，但我认为，如果我能理解以上所有“痛点”，这将真正提高我的“逻辑”理解，并且对新的 python 加入者也非常有益。

我正在关注Tim Mattson关于 OpenMP 的讲座，以了解一些并行编程概念的实现方式。

我试图观察使用3x10^8步计算PI值的并行程序的运行时间行为。

这是代码，

现在我在双核机器上运行 Ubuntu 14.04 LTS。调用omp_get_num_procs()返回2。运行时间完全随机，从 1.31 秒到 4.46 秒不等。而串行程序几乎总是花费 2.31 秒。

我尝试创建 1、2、3、4，最多 10 个线程。每种情况下的运行时间变化太大，尽管在线程更多的情况下平均值会更小。我没有运行任何其他应用程序。

谁能解释为什么运行时间变化太大？

如何准确计算运行时间？讲师给出了他的计算机的运行时间，这似乎是一致的。而且他也在使用双核处理器。

我想知道，哪个更好GridSearchCV( ..., n_jobs = ... )用于为模型选择最佳参数集，n_jobs = -1或者n_jobs使用大数字，
例如n_jobs = 30？

基于 Sklearn 文档：

n_jobs = -1意味着计算将在计算机的所有 CPU 上分派。

在我的 PC 上，我有一个 Intel i3 CPU，它有 2 个内核和 4 个线程，所以这是否意味着如果我设置n_jobs = -1，它会隐含地等于n_jobs = 2？

我正在尝试在 Python (Windows Server 2012) 中实现多处理，并且无法达到我期望的性能改进程度。特别是，对于一组几乎完全独立的任务，我希望通过额外的核心实现线性改进。

我知道——尤其是在 Windows 上——打开新进程会产生开销[1]，并且底层代码的许多怪癖可能会阻碍一个干净的趋势。但理论上，对于完全并行化的任务[2] ，趋势最终仍应接近线性；或者如果我正在处理部分串行任务[3] ，则可能是逻辑的。

N_cores=36但是，当我在质数检查测试函数（下面的代码）上运行 multiprocessing.Pool 时，在我进入预期性能之前，我得到了一个几乎完美的平方根关系（我的服务器上的物理内核数）额外的逻辑核心。

这是我的性能测试结果图：（ _{“标准化性能”是[具有1 个CPU 核心的运行时间]除以[具有N个 CPU 核心的运行时间]）。}

多处理导致收益急剧减少是否正常？还是我的实施遗漏了什么？

注意：我知道对于这个任务，实现多线程可能会更有效，但是由于 GIL，这个简化模拟的实际脚本与 Python 多线程不兼容。

我开始使用 OpenMP 并遵循以下教程：

OpenMP 教程

我正在对视频中出现的内容进行准确编码，但不是通过更多线程获得更好的性能，而是变得更糟。我不明白为什么。

这是我的代码：

如您所见，它与视频中的完全相同，我只是添加了一个代码来测量经过的时间。

在本教程中，我们使用的线程越多，性能就越好。

就我而言，这不会发生。这是我得到的时间：

为什么我会出现这种行为？

- 编辑 -

gcc 版本：gcc 5.5.0

lscpu的结果：

- 编辑 -

我尝试过使用omp_get_wtime()，如下所示：

行为是不同的，尽管我有一些问题。

现在，如果我将线程数增加1，例如1线程，2线程，3、4，...，结果与以前基本相同，性能变差，虽然如果我增加到64线程，或 128 个线程，我确实获得了更好的性能，时间从0.44 [s]（对于 1 个线程）减少到0.13 [s]（对于 128 个线程）。

我的问题是：为什么我的行为与教程中的行为不同？

2 线程比 1 获得更好的性能，
3 线程获得比 2 更好的性能，依此类推。

为什么只有更多的线程才能获得更好的性能？