标签: parallelism

我有三种不同格式的数据；对于每种数据类型，都有一个 Python 脚本将其转换为单一的统一格式。

这个 Python 脚本很慢并且受 CPU 限制（到多核机器上的单核），所以我想运行它的三个实例 - 每个数据类型一个 - 并将它们的输出组合起来将它传递到sort. 基本上，相当于：

{ ./handle_1.py; ./handle_2.py; ./handle_3.py } | sort -n

但是三个脚本并行运行。

我发现了这个问题，其中 GNUsplit被用来在处理流的脚本的 n 个实例之间循环一些标准输出流。

从拆分手册页：

-n, --number=CHUNKS
          generate CHUNKS output files.  See below
CHUNKS  may be:
 N       split into N files based on size of input
 K/N     output Kth of N to stdout
 l/N     split into N files without splitting lines
 l/K/N   output Kth of N to stdout without splitting lines
 r/N …

我正在使用xargs一个 python 脚本来处理大约 3000 万个小文件。我希望用来xargs并行化这个过程。我使用的命令是：

find ./data -name "*.json" -print0 |
  xargs -0 -I{} -P 40 python Convert.py {} > log.txt

基本上，Convert.py会读入一个小的json文件（4kb），做一些处理并写入另一个 4kb 文件。我在具有 40 个 CPU 内核的服务器上运行。并且此服务器上没有运行其他 CPU 密集型进程。

通过监控 htop（顺便说一句，有没有其他好的方法来监控 CPU 性能？），我发现它-P 40没有预期的那么快。有时所有内核会冻结并在 3-4 秒内几乎降至零，然后恢复到 60-70%。然后我尝试将并行进程的数量减少到-P 20-30，但它仍然不是很快。理想的行为应该是线性加速。对 xargs 的并行使用有什么建议吗？

我读过红色表示“内核进程”。这是否意味着小守护进程正在调节哪个任务可以使用 CPU？推而广之，超额认购系统中的交易成本？

我正在运行一些大规模的地理处理作业，并且我有两个同时并行运行的脚本。

第一个脚本在所有 96 个内核上进行实际处理。它负责几乎所有的内存使用。

第二个脚本用于curl下载数据以提供给第一个进程，并且它是并行执行的。我写它只下载直到有n_cores * 3文件下载。如果不满足该约束，它会等待一分钟左右，然后再次检查。所以，大部分时间它没有运行-或者更确切地说，它正在执行Sys.sleep()的命令R。

我已经尝试在下载过程中使用更少的内核。当我这样做时，它跟不上处理脚本（我正在从 S3 进行 DLing）。

TL;DR：如果我可以htop减少红色，我的流程会运行得更快吗？它们是不是因为进程数多于核心数而变红？

我想并行化for以下代码的循环。这该怎么做？

#!/bin/bash
N=$1 
n=$2
for (( i=1; i<=$N; i++ )); do
  min=100000000000000  //set min to some garbage value
  for (( j=1; j<=$n; j++ )); do
    val=$(/path/to/a.out)
    val2=`echo $val | bc`  

      if (( $val2 < $min )); then
        min=$val2; 
      fi
  done
  arr=("${arr[@]}" "$min")
done

我需要通过 FTP 上传一个带有相当复杂的树（很多子目录等）的目录。我无法压缩这个目录，因为除了 FTP 之外我没有任何访问目标的权限 - 例如没有 tar。由于这是一个很长的距离（美国 => 澳大利亚），延迟非常高。

遵循如何在 Unix 中使用 mput 将多个文件夹通过 FTP 传输到另一台服务器中的建议？，我目前使用的ncftp执行与转移mput -r。不幸的是，这似乎一次传输一个文件，在通信开销上浪费了大量可用带宽。

有什么办法可以并行化这个过程，即同时从这个目录上传多个文件？当然，我可以手动拆分它并mput -r在每个块上执行，但这是一个乏味的过程。

CLI 方法是非常受欢迎的，因为客户端机器实际上是一个通过 SSH 访问的无头服务器。

我编写了一个 bash 脚本，格式如下：

#!/bin/bash
start=$(date +%s)
inFile="input.txt"
outFile="output.csv"

rm -f $inFile $outFile

while read line
do

    -- Block of Commands

done < "$inFile"

end=$(date +%s)

runtime=$((end-start))

echo "Program has finished execution in $runtime seconds."

该while循环将从读取$inFile，上线执行一些活动和转储结果$outFile。

由于$inFile有 3500 多行长，脚本完全执行需要 6-7 个小时。为了尽量减少这个时间，我计划在这个脚本中使用多线程或分叉。如果我创建 8 个子进程，$inFile将同时处理 8 行。

如何才能做到这一点？

工作中的海洋学家朋友需要备份数月的数据。她不知所措，所以我自愿去做。有数百个目录需要备份，我们希望将它们 tar/bzip 压缩到与目录同名的文件中。我可以连续轻松地完成此操作 - 但是 - 我想利用我工作站上的数百个内核。

问：使用find与-n -PARGS或GNU并行，我怎么焦油/ bZIP结构的目录，使用尽可能多的内核，同时尽可能的命名最终产品： origonalDirName.tar.bz2？

我已经使用 find 同时 bunzip 100 个文件并且它非常快 - 所以这是解决问题的方法，尽管我不知道如何让每个文件名成为每个目录的文件名。

在 Bash 中，让我们考虑一个函数，它除了echo后跟“是一个整数”的参数之外什么都不做。

f () { num="${!1}"; echo $num is an integer; }
number=12
f number
# 12 is an integer

我想在一个文件上写一些使用该函数的命令，f然后使用该函数parallel（GNU）并行运行这些命令。

# Write Commands to the file `Commands.txt`
rm Commands.txt
touch Commands.txt
for i in $(seq 1 5)
do
   echo "number=$i; f number" >> Commands.txt
done

随着source一切工作正常

source Commands.txt
1 is an integer
2 is an integer
3 is an integer
4 is an integer
5 is an integer

但是，当我尝试并行运行命令时，它返回f …

我需要为我的并发程序运行性能测试，我的要求是它应该只在一个CPU 内核上运行。（我不想合作线程 - 我希望总是有一个上下文切换）。

所以我有两个问题：

1. 最佳解决方案 - 如何仅为我的程序签名和保留一个 CPU 内核（以强制操作系统不使用此 CPU 内核）。我想这是不可能的，但也许我错了......

2. 如何设置 linux (Fedora 24) 只使用一个 CPU 核心？

我有一个小脚本，它循环遍历文件夹的所有文件并执行（通常是持久的）命令。基本上是

for file in ./folder/*;
do
    ./bin/myProgram $file > ./done/$file
done

（请忽略语法错误，这只是伪代码）。

我现在想同时运行这个脚本两次。显然，如果 ./done/$file 存在，则不需要执行。所以我把脚本改成了

for file in ./folder/*;
do
    [ -f ./done/$file ] || ./bin/myProgram $file >./done/$file
done

所以基本上问题是：两个脚本（或通常不止一个脚本）是否可能实际上处于同一点并检查done失败且命令运行两次的文件是否存在？

这将是完美的，但我非常怀疑。这太容易了 :D 如果他们处理同一个文件可能发生，是否有可能以某种方式“同步”脚本？