我有一个简单的 bash 脚本可以运行：
cat full_path.csv | parallel --progress -j +0 'echo -n {},; pdfgrep -c [^_] {};' > path_count.csv
Parallel 的进度指示器"--progress"，写入文件path_count.csv。我只想echo {}和pdfgrep {}写入文件，同时显示--progress到屏幕输出。
如果我做 ：
cat full_path.csv | parallel --progress -j +0 'echo -n {},>>path_count.csv; pdfgrep -c [^_] {}>>path_count.csv;'
文件 path_count 仍然是乱码。
任何帮助表示赞赏。谢谢阿尔文
我正在数值求解一个取决于参数的微分方程。我对解决方案并不真正感兴趣，而是对它们根据参数值而定的行为感兴趣。因为我想要一个非常精确的描述，所以我必须使用一个非常精细的参数值数组，从而导致许多 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(), …我熟悉foreach,%dopar%之类的。我也是熟悉parallel的选项cv.glmnet。但是你如何设置嵌套的并行性如下？
library(glmnet)
library(foreach)
library(parallel)
library(doSNOW)
Npar <- 1000
Nobs <- 200
Xdat <- matrix(rnorm(Nobs * Npar), ncol = Npar)
Xclass <- rep(1:2, each = Nobs/2)
Ydat <- rnorm(Nobs)
并行交叉验证：
cl <- makeCluster(8, type = "SOCK")
registerDoSNOW(cl)
system.time(mods <- foreach(x = 1:2, .packages = "glmnet") %dopar% {
idx <- Xclass == x
cv.glmnet(Xdat[idx,], Ydat[idx], nfolds = 4, parallel = TRUE)
})
stopCluster(cl)
非并行交叉验证：
cl <- makeCluster(8, type = "SOCK")
registerDoSNOW(cl)
system.time(mods <- foreach(x …我的理解是 concurrent.futures 依靠酸洗参数来让它们在不同的进程（或线程）中运行。酸洗不应该创建参数的副本吗？在 Linux 上它似乎没有这样做，即，我必须明确地传递一个副本。
我试图理解以下结果：
<0> rands before submission: [17, 72, 97, 8, 32, 15, 63, 97, 57, 60]
<1> rands before submission: [97, 15, 97, 32, 60, 17, 57, 72, 8, 63]
<2> rands before submission: [15, 57, 63, 17, 97, 97, 8, 32, 60, 72]
<3> rands before submission: [32, 97, 63, 72, 17, 57, 97, 8, 15, 60]
in function 0 [97, 15, 97, 32, 60, 17, 57, 72, 8, 63]
in function 1 [97, 32, …python parallel-processing multiprocessing python-3.x concurrent.futures
我正在使用 OpenMP 并且我想生成线程，以便一个线程执行一段代码并完成，与运行并行 for 循环迭代的 N 个线程并行。
执行应该是这样的：
Section A (one thread) || Section B (parallel-for, multiple threads)
| || | | | | | | | | | |
| || | | | | | | | | | |
| || | | | | | | | | | |
| || | | | | | | | | | |
| || | | | | | | | | | |
V || …