问题标签 [parallelism-amdahl]

我有一个功能可以有效地生成图像并存储到磁盘中。该函数没有参数：

我需要生成大量图像（比如 100k），所以我选择了 Dask。阅读手册后，我整理了一个创建分布式（本地）客户端并使用多个进程执行任务的函数，如下所示：

如您所见，“期货”在 for 循环中提交给服务器并存储在一个简单的列表中。问题是：在这种情况下，是否有更有效的方式来添加和执行期货？例如，并行化提交过程本身？

我正在尝试对计算进行基准测试，f(x)同时在每次迭代中改变线程数。

f(x) = c * ln(x) * cos(x)

n=10000000

结果：

开始了不同的线程：

并行：对于 n=10000000，p=2，所用时间=0.153774，加速=3.503831

并行：对于 n=10000000，p=3，耗时=0.064447，加速比=8.360370

并行：对于 n=10000000，p=4，耗时=0.044694，加速=12.055239

并行：对于 n=10000000，p=5，耗时=0.048700，加速=11.063550

并行：对于 n=10000000，p=6，所用时间=0.039009，加速比=13.811989

并行：对于 n=10000000，p=7，所用时间=0.041735，加速=12.910017

并行：对于 n=10000000，p=8，耗时=0.041268，加速=13.055919

并行：对于 n=10000000，p=9，所用时间=0.039032，加速=13.804157

并行：对于 n=10000000，p=10，耗时=0.038970，加速=13.825767

并行：对于 n=10000000，p=11，耗时=0.039843，加速=13.522884

并行：对于 n=10000000，p=12，耗时=0.041356，加速=13.028237

并行：对于 n=10000000，p=13，所用时间=0.041039，加速=13.128763

并行：对于 n=10000000，p=14，耗时=0.047433，加速=11.359218

并行：对于 n=10000000，p=15，耗时=0.048430，加速=11.125202

并行：对于 n=10000000，p=16，耗时=0.051950，加速=10.371477

注意：此处的加速比是根据顺序算法计算的（线程 = 1）

加速似乎并没有真正受到p（线程数）变化的影响。

我这样做是否正确，或者原因来自线程数的非有效增量（即理论上讲更改p不会严重影响O(myprogram)）？

我正在尝试查看是否可以使用 Chapel 编写用于基于 Python 的气候模型的并行代码： https ://github.com/CliMT/climt

我对 Chapel 没有任何经验，但它对我的用例来说似乎很有希望。关于如何将 Chapel 代码集成到我当前的工作流程中，我有几个问题：

1. 我知道您可以构建可导入.so的文件，但是生成 Cython 文件时可以停止编译吗？然后我可以将它包含到发行版中并使用标准setuptools在 Travis 上编译我的项目。

2. 我可以将numpy数组传递给用 Chapel 编写的 Python 扩展吗？

3. 如果对 2. 的回答是肯定的，并且我的计算在数组的一维上是并行的，那么在 Chapel 中是否有一种优雅的方式来表达这种并行性？

4. 如果我编写适用于多个节点的 Chapel 代码并将其编译为 Python 扩展，我该如何运行它？我可以使用mpirun python my_code.py某种命令吗？

我正在编写一个使用 Executorservice 框架处理矩阵并行编程的程序。而且我将fixedpoolsize设置为4，但令我惊讶的是，当矩阵维度设置为5000时，使用多线程对串行执行的加速大于4（这也是我的CPU内核）。而且我已经检查过我的 CPU 不支持超线程。

实际上，我使用 Callable 和 Future 容器，因为我的多线程任务需要返回结果。

简而言之，我只是将内部循环拿走，让它由线程运行，而外部循环保持不变。

但是加速怎么可能是这样的呢？

因为从我之前的概念来看，最大加速只能是 4。我已经检查过该任务实际上是由 4 个线程完成的。

我必须为一堆图像的每个切片应用 2D 过滤器，并且我想并行化分析。但是，下面的代码运行速度比正常的 for 循环慢。此外，增加n_jobs也会增加处理时间，n_jobs = 1对于n_jobs = 6.

下面的代码是一个人为的示例，它模拟了我使用多处理来加速代码的实际问题。代码运行在Windows 10 64-bit OS, python 3.7.5, 和ipython 7.9.0

转换函数（这些函数将用于转换数组main()）

多处理部分

出于性能原因，所有进程之间使用多个共享的“只读”字典以减少冗余计算（在实际问题中，在所有进程之间使用共享字典后，总计算时间减少了 40%）。但是，在我的实际问题中使用共享字典后，ram 的使用率变得高得多；我的 6C/12T Windows 计算机的内存使用量从（峰值 8.2GB，空闲 5.0GB）变为（峰值 23.9GB，空闲 5.0GB），为了获得 40% 的加速，付出的成本有点太高了。

当必须在进程之间使用多个共享数据时，高内存使用是否不可避免？可以对我的代码做些什么，以便在使用尽可能低的内存的同时使其尽可能快？

先感谢您

注意：我尝试使用imap_unordered()而不是map因为我听说当输入迭代很大时它应该减少内存使用量，但老实说我看不到内存使用量的改进。也许我在这里做错了什么？

编辑：由于答案中的反馈，我已经更改了代码的繁重计算部分，使其看起来不那么虚拟，并且类似于实际问题中的计算。

如何parfor在亚马逊的虚拟机上找到最佳的工作人员数量？

对于哪些情况，我应该使用物理内核的数量和逻辑内核的数量？

这有什么“经验法则”吗？

我运行编译代码（可执行代码）。

回想一下关于估计最佳可能加速的阿姆达尔定律。回答以下问题。

您有一个程序，其 40% 的代码在三个处理器上并行化，仅对于这部分代码，就实现了 2.3 的加速。什么是整体加速？

在这个问题中，我无法理解加速和整体加速之间的区别。我知道这个问题的措辞肯定有所不同。

CyclicDist我尝试使用模块来实现矩阵乘法。

当我使用一种语言环境与两种语言环境进行测试时，一种语言环境要快得多。是因为两个 Jetson nano 板之间的通信时间真的很大，还是我的实现没有利用这种工作方式CyclicDist？

这是我的代码：

我知道我的实现对于分布式内存系统来说并不是最优的。

当向我们的硬件添加越来越多的处理能力时，阿姆达尔定律让我们计算程序的最大理论加速。这可以通过
T = 1 / ((1-P) + (P/N))where(1-P)是顺序的程序部分来说明，并且(P/N)是可以从加速中受益的部分。现在，阿姆达尔定律遗漏了开销因素。要将其计入其中，我们可以说
T = 1 / ((1-P) + 0(N) + (P/N))哪里0(N)表示随着计算节点数量的增加而增加的同步工作量。

现在我的问题是：如何计算程序的最大加速比0(N)？假设我们有一个程序，其顺序部分为25%，并行部分为75%。