我正在阅读 Julia 的并行计算文档，并且从未做过任何并行编码，所以我想要一个更温和的介绍。所以，我想到了一个（可能）简单的问题，我无法弄清楚如何在并行 Julia 范式中进行编码。
假设我有一个df来自某个实验的矩阵/数据框。它的N行是变量，M列是样本。我有一种pwCorr(..)计算行的成对相关性的方法。如果我想要一个包含所有成对相关性的 NxN 矩阵，我可能会运行一个 for 循环来迭代N*N/2（矩阵的上三角或下三角）并填充值；然而，这似乎是一个完美的并行化方法，因为每个调用pwCorr()都是独立于其他调用的。（我对什么可以并行、什么不能并行的这种思考正确吗？）
为此，我觉得我必须创建一个DArray由 for 循环填充的对象@parallel。如果是这样，我不确定如何在 Julia 中实现这一点。如果这不是正确的方法，我想我什至不知道从哪里开始。
在haskell中，假设我有一个以下形式的函数调用：foo a b，其中a不依赖于b，反之亦然。看起来它可以自动检测到a并且b可以并行评估，但在 GHC 中似乎并非如此。相反，需要使用像 need 这样的结构par来表示可以并行评估的内容。
那么，为什么 Haskell 中的并行化不能自动发生呢？或者，如果已经存在，为什么还会par存在这样的结构？
我无法理解 mclapply （或者其他东西）的行为。
我做类似的事情：
opt.Models = mclapply(1:100, mc.cores=20, function(i){
res = loadResult(reg, id=i)
return(post.Process(res))
})
loadResult加载先前保存的 BatchJob 会话的一个结果。因此，该res对象需要约 170MB（大约所有 100 个对象的大小都相同 +/-5MB）。执行这段代码时，内存占用量符合预期：170MB*20= ~3.5GB（我使用了20个核心）。当第二次执行这段代码时，我的机器吸入大量内存（超过可用内存 - 所以我停止执行）。这是预期的，因为再次为每个孩子分叉完整的环境，我的环境现在有大约 10GBmclapply的大变量。opt.Models因此需要 10*20=200GB。
当我删除 opt.Models, 时rm(opt.Models)，我仍然遇到同样的问题。mclapply 消耗的内存超过可用内存（顺便说一句：90GB）。那么，mclapply 分叉了哪个环境，或者 opt.Models 没有完全消失？我看不到它使用ls().
也许你们中的一个人也观察到了类似的事情。
此致，
马里奥
我有一个程序，目前需要很长时间才能使用 来总结std::vector约 1 亿个元素的大数据std::accumulate，这是一个瓶颈。
我希望它更快，并且我希望它是异步计算，这样 GUI/服务器就不会阻塞。计算还应该使用多线程，这样我就可以减少求和向量所需的时间。
我想将求和分开，以便每个线程对向量的一部分求和，然后在计算所有部分和时，应将每个线程的部分和加在一起以获得总和。
我想知道如何在Boost.Asio中解决这个问题？理想情况下，我的程序需要重用线程（如线程组），不确定如何存储和检索部分总和并最终检索部分总和的总和。
我正在考虑创建一个调用 的线程组boost::asio::io_service::run，传递一个处理程序来计算部分和，但我不确定如何将部分和传递给另一个处理程序并将所有部分和加在一起。
如果有人展示一些我如何解决这个问题的框架代码，那就太好了。
我是一个相当新的 cuda 用户。我正在练习我的第一个 cuda 应用程序，尝试使用 GPU(GTX 670) 加速 kmeans 算法。
简而言之，每个线程都在一个点上工作，该点与所有聚类中心进行比较，并将一个点分配给具有最小距离的中心（内核代码可以在下面看到，并附有注释）。
根据 Nsight Visual Studio，我的占用率为 99.61%（1024 个块，每个块 1024 个线程），流式多处理器活动为 99.34%，扭曲问题效率为 79.98%，无共享内存库冲突，单个 MUL 为 18.4GFLOP，单个 ADD 为 55.2 GFLOP （使用给定参数完成 kmeans 内核大约需要 14.5 毫秒）。
根据维基百科，GTX670 的峰值性能为 2460 GFLOPs。我离它还差得很远。除此之外，一些论文声称它们可以达到峰值性能的一半以上。我不知道如何进一步优化这个内核代码。我可以对内核进行任何优化吗？如有任何建议或帮助，我们将不胜感激，我可以根据需要提供任何其他信息。
提前致谢。
#define SIZE 1024*1024 //number of points
#define CENTERS 32 //number of cluster centroids
#define DIM 8 //dimension of each point and center
#define cudaTHREADSIZE 1024 //threads per block
#define cudaBLOCKSIZE SIZE/cudaTHREADSIZE //number of blocks for kernel
__global__ void kMeans(float *dp, float …我正在使用 R 中的 LQMM 包进行非常耗时的分析。我将模型设置为从星期四开始运行，现在是星期一，并且仍在运行。我对模型本身充满信心（作为标准 MLM 进行测试），并且对我的 LQMM 代码充满信心（已经使用相同的数据集运行了其他几个非常相似的 LQMM，并且它们都花费了一天的时间来运行）。但我真的很想弄清楚如何使用我可以访问的机器的并行处理功能（注意所有机器都是基于 Microsoft Windows 的），如果可能的话，使其运行得更快。
我已经阅读了几篇关于使用并行的教程，但我还没有找到一个展示如何将并行包与其他 R 包配合使用的教程......我是否想太多了，或者这是不可能的？
这是我使用 R 包 LQMM 运行的代码：
install.packages("lqmm")
library(lqmm)
g1.lqmm<-lqmm(y~x+IEP+pm+sd+IEPZ+IEP*x+IEP*pm+IEP*sd+IEP*IEPZ+x*pm+x*sd+x*IEPZ,random=~1+x+IEP+pm+sd+IEPZ, group=peers, tau=c(.1,.2,.3,.4,.5,.6,.7,.8,.9),na.action=na.omit,data=g1data)
该数据集有 58 个变量的 122433 个观测值。所有变量均经过 z 评分或虚拟编码。
这是设计和代码问题的很大结合。
用例
- 给定范围内的许多日志文件（2MB - 2GB），我需要解析每个日志并应用一些处理，生成 Java POJO.
- 对于这个问题，我们假设我们只有1日志文件
- 另外，这个想法是充分利用 System. 可以使用多个核心。
替代方案 1
- 打开文件（同步），读取每一行，生成POJOs
FileActor -> read each line -> List<POJO>
优点：简单易懂
缺点：串行过程，没有利用系统中的多个核心
替代方案 2
- 打开文件（同步），读取N行（N可配置），传递给不同的参与者进行处理
/ LogLineProcessActor 1
FileActor -> LogLineProcessRouter (with 10 Actors) -- LogLineProcessActor 2
\ LogLineProcessActor 10
优点一些并行化，通过使用不同的参与者来处理部分线路。参与者将利用系统中的可用核心（？如何，可能？）
缺点仍然是串行的，因为文件以串行方式读取
问题
- 以上选择是一个不错的选择吗？
- 有更好的选择吗？
请在此提供宝贵的想法
多谢
我有一个嵌套列表理解，看起来像这样：
>>> nested = [[1, 2], [3, 4, 5]]
>>> [[sqrt(i) for i in j] for j in nested]
[[1.0, 1.4142135623730951], [1.7320508075688772, 2.0, 2.23606797749979]]
是否可以使用标准 joblib 方法将其并行化以实现令人尴尬的并行 for 循环？如果是这样，正确的语法是什么delayed？
据我所知，文档没有提及或给出任何嵌套输入的示例。我尝试了一些简单的实现，但没有成功：
>>> #this syntax fails:
>>> Parallel(n_jobs = 2) (delayed(sqrt)(i for i in j) for j in nested)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "C:\Python27\lib\site-packages\joblib\parallel.py", line 660, in __call__
self.retrieve()
File "C:\Python27\lib\site-packages\joblib\parallel.py", line 512, in retrieve
self._output.append(job.get())
File "C:\Python27\lib\multiprocessing\pool.py", line 558, …我有一个df交易者交易数据集。我有 2 个级别的 for 循环，如下所示：
smartTrader =[]
for asset in range(len(Assets)):
df = df[df['Assets'] == asset]
# I have some more calculations here
for trader in range(len(df['TraderID'])):
# I have some calculations here, If trader is successful, I add his ID
# to the list as follows
smartTrader.append(df['TraderID'][trader])
# some more calculations here which are related to the first for loop.
我想并行化 中每个资产的计算Assets，并且我还想并行化每个资产的每个交易者的计算。完成所有这些计算后，我想根据smartTrader.
这是我第一次尝试并行处理，所以请耐心等待，非常感谢您的帮助。
它说：
\n\n\n\n\n该算法有一个关键路径长度的
\n\xce\x98((log n)^2)步骤，这意味着在具有无限数量处理器的理想机器上需要那么多时间；因此，它在任何真实计算机上都有最大可能的加速\xce\x98(n3/((log n)^2))。
（引用来自“并行和分布式算法/共享内存并行性”部分。）
\n\n由于假设有无限个处理器，乘法运算应该在 中完成O(1)。然后将所有元素相加，这也应该是一个常数时间。因此，最长的关键路径应该是O(1) 而不是 \xce\x98((log n)^2)。
我想知道 O 和 \xce\x98 之间是否有区别，我错在哪里？
\n\n问题已经解决，非常感谢@Chris Beck。答案应该分为两部分。
\n\n首先，一个低级错误是我没有计算求和的时间。求和进行运算O(log(N))（考虑二进制加法）。
其次，正如克里斯指出的那样，重要的问题需要O(log(N))处理器花费时间。最重要的是，最长的关键路径应该是O(log(N)^2)而不是O(1)。
对于 O 和 \xce\x98 的混淆，我在Big_O_Notation_Wikipedia中找到了答案。
\n\n\n\n\nBig O 是比较函数时最常用的渐近表示法，尽管在许多情况下 Big O 可以替换为 Big Theta \xce\x98 以获得渐近更紧的界限。
\n
我最后的结论是错误的。这O(log(N)^2)不会发生在求和和处理器处，而是发生在我们分割矩阵时。感谢@displayName 提醒我这一点。此外，Chris对非平凡问题的回答对于研究并行系统仍然非常有用。感谢下面所有暖心回答者！