我即将开始一个项目，该项目将获取文本块，将大量数据解析为某种对象，然后可以对其进行序列化、存储和统计/收集数据。这需要尽可能快，因为我需要开始处理 > 10,000,000 个文本块，并且每天将收到 100,000 条。
我在具有 12 个至强核心 + 超线程的系统上运行它。我也可以访问/了解一些关于 CUDA 编程的知识，但对于字符串内容，我认为它不合适。从每个字符串中，我需要解析大量数据，其中一些我知道确切的位置，有些我不知道并且需要使用正则表达式/一些聪明的东西。
所以考虑这样的事情：
object[] parseAll (string [] stringsToParse)
{
parallel foreach
parse( string[n] )
}
object parse(string s)
{
try to use exact positions / substring etc here instead of regex's
}
所以我的问题是：
谢谢你的帮助！对不起，如果这是冗长的。
在一个项目中，我被要求通过 Java 实现共享内存并行化JaMP，它扩展了 Java for OpenMP。我几乎是该领域的初学者，经过 10 分钟的搜索，互联网并没有证明自己很有帮助。
我的主要问题：是JaMP仅 linux 的实现吗？如果没有，开始学习的良好起点是什么？
我使用 MPI 编写了一个小程序来并行化矩阵-矩阵乘法。问题是：在我的电脑上运行程序时，大约需要10秒才能完成，但在集群上大约需要75秒。我想我有一些同步问题，但我无法弄清楚（还）。
这是我的源代码：
/*matrix.c
mpicc -o out matrix.c
mpirun -np 11 out
*/
#include <mpi.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define N 1000
#define DATA_TAG 10
#define B_SENT_TAG 20
#define FINISH_TAG 30
int master(int);
int worker(int, int);
int main(int argc, char **argv) {
int myrank, p;
double s_time, f_time;
MPI_Init(&argc,&argv);
MPI_Comm_rank(MPI_COMM_WORLD, &myrank);
MPI_Comm_size(MPI_COMM_WORLD, &p);
if (myrank == 0) {
s_time = MPI_Wtime();
master(p);
f_time = MPI_Wtime();
printf("Complete in %1.2f seconds\n", f_time - s_time);
fflush(stdout);
}
else {
worker(myrank, …我想在不同的线程中训练多个一类 SVM。有人知道 scikit 的 SVM 是否发布了 GIL？我在网上没有找到任何答案。
谢谢
python parallel-processing multithreading machine-learning scikit-learn
我正在数值求解一个取决于参数的微分方程。我对解决方案并不真正感兴趣，而是对它们根据参数值而定的行为感兴趣。因为我想要一个非常精确的描述，所以我必须使用一个非常精细的参数值数组，从而导致许多 ODE 求解过程。所以我想知道是否有可能“并行化”这样一个程序。这个想法是，也许我计算机的每个处理器都可以为一对不同的参数求解 ODE。一种示例如下：
import matplotlib.pyplot as plt
from scipy.integrate import ode
import numpy as np
# - ODE - #
def sys(t,x,p1,p2): #p1 and p2 are the parameters
dx=np.zeros(2)
dx[0] = x[1]
dx[1] = (p1+p2*cos(t))*x[0]
return dx
t0=0; tEnd=10; dt=0.01
r = ode(sys).set_integrator('dopri5', nsteps=10,max_step=dt)
Y=[];S=[];T=[]
ic=[.1,0]
# - parameters range - #
P1=np.linspace(0,1,100)
P2=np.linspace(0,1,100)
# -------------------- #
for p1 in P1:
for p2 in P2:
r.set_initial_value(ic, t0).set_f_params(p1,p2)
flag='No'
while r.successful() and r.t +dt < tEnd:
r.integrate(r.t+dt)
Y.append(r.y)
T.append(r.t)
#-This …python parallel-processing numpy numerical-methods differential-equations
我正在研究自适应矩阵向量乘法的 MATLAB 实现，用于来自 PDE 的特定离散化（具有已知的稀疏结构）的非常大的稀疏矩阵。
经过大量预处理后，我最终得到了许多不同的块（比方说，大于 200），我想为它们计算选定的条目。
预处理步骤之一是确定我想要计算的每个块的（数量）条目，这使我几乎可以完美地衡量每个块将花费的时间（对于所有意图和目的，正交工作是每个条目相同）。
感谢/sf/answers/695706651/，我能够通过以相反的顺序对块进行排序来利用它，从而促使 MATLAB 首先从最大的块开始。
然而，条目的数量因块而异，以至于直接运行 parfor 受到条目数量最多的块的严重限制，即使它们被反向送入循环。
我的解决方案是串行执行最大的块（但在条目级别并行！），只要每个 iterand 的开销无关紧要，就可以了。块不会变得太小。然后我用 parfor 做其余的块。理想情况下，我会让 MATLAB 决定如何处理这个问题，但是由于嵌套的 parfor 循环失去了并行性，所以这不起作用。此外，将两个循环打包成一个（几乎）是不可能的。
我现在的问题是关于如何最好地确定串行和并行机制之间的这个截止点，考虑到我对条目数量的信息（不同问题的有序条目曲线的形状可能不同），如以及我可用的工人数量。
到目前为止，我一直在与标准 PCT 许可下的 12 个工作人员一起工作，但是自从我现在开始在一个集群上工作，确定这个截止变得越来越重要（因为对于许多内核来说，与并行循环相比，串行循环变得越来越昂贵，但类似地，拥有阻止其余部分的块的成本甚至更高）。
对于 12 个内核（对应于我正在使用的计算服务器的配置），我已经找到了一个合理的参数，即每个工人 100 个条目作为截止，但是当内核数不是相对于块的数量来说小了（例如 64 对 200）。
我试图减少具有不同功率（例如 1/2、3/4）的内核数量，但这也不能始终如一地工作。接下来，我尝试将块分组并确定当条目大于每批的平均值时的截止值，分别是。他们离结束的批次数：
logical_sml = true(1,num_core); i = 0;
while all(logical_sml)
i = i+1;
m = mean(num_entr_asc(1:min(i*num_core,end))); % "asc" ~ ascending order
logical_sml = num_entr_asc(i*num_core+(1:num_core)) < i^(3/4)*m;
% if the small blocks were parallelised perfectly, i.e. all
% cores take the same …我正在尝试使用 Multiprocessing 和 Pool.map() 命令并行化我一直在研究的算法。我遇到了一个问题，希望有人能指出我正确的方向。
让 x 表示一个 N 行 1 列的数组，它被初始化为一个零向量。让 C 表示一个长度为 N 乘以 2 的数组。向量 x 是通过使用来自 C 的某些子集的信息（进行一些数学运算）迭代构建的。作为大型 for 循环的代码（未并行化）大致如下所示：
for j in range(0,N)
#indx_j will have n_j <<N entries
indx_j = build_indices(C,j)
#x_j will be entries to be added to vector x at indices indx_j
#This part is time consuming
x_j = build_x_j(indx_j,C)
#Add x_j into entries of x
x[indx_j] = x[indx_j] + x_j
我能够使用 multiprocessing 模块并行化它并使用 pool.map 来消除大型 for 循环。除了将 x_j 添加到 x[indx_j] 的步骤之外，我编写了一个执行上述计算的函数。相反，并行化函数返回两个数据集：x_j …
我想这个问题/问题可以通过满足以下一个（或多个）问题来解决
1) 如何显示剩余的工作？2）我如何漂亮的输出--eta
1) 我已经检查了手册页，我目前在我的函数中使用 $PARALLEL_SEQ，但是我怎样才能获得剩余的工作？Parallel 帮助我编译了大约 800 个文件，我想知道我的剩余工作。
2）或者，有没有更好（更好）的输出方式--eta？我的输出看起来很乱。我只想看到一个 ETA。
我使用的并行标志： --no-notice --keep-order --group
输出示例：
819: Compiling form: USER_Q ok
ETA: 8s 13left 0.61avg local:4/819/100%/0.6s
820: Compiling form: USER_RESERVE_STOCK ok
ETA: 7s 12left 0.61avg local:4/820/100%/0.6s
821: Compiling form: USERS_AUTO ok
ETA: 7s 11left 0.61avg local:4/821/100%/0.6s
822: Compiling form: USERS ok
ETA: 6s 10left 0.61avg local:4/822/100%/0.6s
823: Compiling form: USERS_MENU ok
ETA: 6s 9left 0.61avg local:4/823/100%/0.6s
824: Compiling form: USER_SUPP ok
ETA: 4s 8left 0.61avg local:4/824/100%/0.6s
825: …我有一个多模块的 maven 项目，并希望利用 Maven 3 中的并行构建功能。但其中一些模块为未来的模块奠定了基础（按顺序构建时，例如创建一些目录、下载一些非 maven jar 等）。有没有办法让我部分控制并行性，以便构建按顺序开始然后并行并最终收敛到最终模块，该模块进行聚合并且不能在其他模块之前运行？
提前致谢
我创建了各种参考类来适应一些 arima、garch 过程，并希望在并行计算中使用它们 parSapply
我先做了一些导出
cl <- makeCluster(mc <- getOption("cl.cores", 20))
clusterExport(cl, c("merge.xts", "index", "coredata", "xts", "lag.xts", "zoo", "LearnerPredict", "arima", "generic_learner", "arma_simple", "logwarn"))
clusterEvalQ(cl, "arma_simple")
clusterEvalQ(cl, "generic_learner")
generic_learner <- setRefClass(
Class = "generic_learner",
fields = list(
params = "list"
),
methods = list(
fitModel = function() {cat("overload function with fitting function \n")},
fcastModel = function() {cat("overload function with forecast function \n")},
fmt_params = function() {cat("overload function with formatted parameters \n")},
fmt_class = function() {cat("overload class\n")},
fmt_ref = function() {paste(.self$fmt_class(), .self$fmt_params(), …