Parallel processing 如果我运行的子对象多于分配的核心数量，会发生什么

所以我有一个sbatch（slurmjobscheduler）脚本，其中我通过3个脚本处理大量数据：foo1.sh、foo2.sh和foo3.sh

foo1.sh和foo2.sh是独立的，我想同时运行它们。 foo3.sh需要foo1.sh和foo2.sh的输出，因此我正在构建一个依赖项。 然后我必须重复30次

比如说：

## Resources config
#SBATCH --ntasks=30
#SBATCH --task-per-core=1

for i in {1..30};
do
    srun -n 1 --jobid=foo1_$i ./foo1.sh &
    srun -n 1 --jobid=foo2_$i ./foo2.sh &
    srun -n 1 --jobid=foo3_$i --dependency=afterok:foo1_$1:foo2_$i ./foo3.sh &
done;
wait

我们的想法是启动foo1_1和foo2_1，但由于foo3_1必须等待其他两个作业完成，因此我想进入下一个迭代。下一次迭代将启动foo1\u2foo2，foo3\u2将等待，等等

然后，在某个时刻，使用srun启动的子对象的数量将高于--ntasks=30。会发生什么？它会等待以前的工作完成（我正在寻找的行为）

---

谢谢，如果启动的子任务多于核心或超线程，那么操作系统调度算法应该处理任务的优先级。根据您正在运行的操作系统（即使它们都是基于Unix的），在后台实现的方式将有所不同

---

但是您的假设是正确的，即如果内核用完了，那么您的并行任务在某种意义上必须“等待轮到它们了”。

应该发生的是，如果启动的子任务多于内核或超线程，那么OS调度算法应该处理任务的优先级。根据您正在运行的操作系统（即使它们都是基于Unix的），在后台实现的方式将有所不同

---

但是您的假设是正确的，即如果内核用完了，那么您的并行任务在某种意义上必须“等待轮到它们了”。

应该发生的是，如果启动的子任务多于内核或超线程，那么OS调度算法应该处理任务的优先级。根据您正在运行的操作系统（即使它们都是基于Unix的），在后台实现的方式将有所不同

---

但是您的假设是正确的，即如果内核用完了，那么您的并行任务在某种意义上必须“等待轮到它们了”。

应该发生的是，如果启动的子任务多于内核或超线程，那么OS调度算法应该处理任务的优先级。根据您正在运行的操作系统（即使它们都是基于Unix的），在后台实现的方式将有所不同

---

但您的假设是正确的，即如果内核用完，那么您的并行任务在某种意义上必须“等待轮到它们了”。

Slurm将运行30个

srun

，但第31个将等待在30个内核分配中释放一个内核。 请注意，正确的参数是

--ntasks per core=1

，而不是

--tasks per core=1

您可以使用salloc而不是sbatch自己进行测试，以交互方式工作：

$ salloc --ntasks=2 --ntasks-per-core=1
$ srun -n 1 sleep 10 & srun -n 1 sleep 10 & time srun -n 1 echo ok
[1] 2734
[2] 2735
ok
[1]-  Done                    srun -n 1 sleep 10
[2]+  Done                    srun -n 1 sleep 10

real    0m10.201s
user    0m0.072s
sys 0m0.028s

---

您可以看到，简单的

echo

花费了10秒，因为第三个

srun

必须等待前两个完成，因为分配只有两个内核。

Slurm将运行30个

srun

，但第31个将等待在30个内核分配中释放一个内核。 请注意，正确的参数是

--ntasks per core=1

，而不是

--tasks per core=1

您可以使用salloc而不是sbatch自己进行测试，以交互方式工作：

$ salloc --ntasks=2 --ntasks-per-core=1
$ srun -n 1 sleep 10 & srun -n 1 sleep 10 & time srun -n 1 echo ok
[1] 2734
[2] 2735
ok
[1]-  Done                    srun -n 1 sleep 10
[2]+  Done                    srun -n 1 sleep 10

real    0m10.201s
user    0m0.072s
sys 0m0.028s

---

您可以看到，简单的

echo

花费了10秒，因为第三个

srun

必须等待前两个完成，因为分配只有两个内核。

Slurm将运行30个

srun

，但第31个将等待在30个内核分配中释放一个内核。 请注意，正确的参数是

--ntasks per core=1

，而不是

--tasks per core=1

您可以使用salloc而不是sbatch自己进行测试，以交互方式工作：

$ salloc --ntasks=2 --ntasks-per-core=1
$ srun -n 1 sleep 10 & srun -n 1 sleep 10 & time srun -n 1 echo ok
[1] 2734
[2] 2735
ok
[1]-  Done                    srun -n 1 sleep 10
[2]+  Done                    srun -n 1 sleep 10

real    0m10.201s
user    0m0.072s
sys 0m0.028s

---

您可以看到，简单的

echo

花费了10秒，因为第三个

srun

必须等待前两个完成，因为分配只有两个内核。

Slurm将运行30个

srun

，但第31个将等待在30个内核分配中释放一个内核。 请注意，正确的参数是

--ntasks per core=1

，而不是

--tasks per core=1

您可以使用salloc而不是sbatch自己进行测试，以交互方式工作：

$ salloc --ntasks=2 --ntasks-per-core=1
$ srun -n 1 sleep 10 & srun -n 1 sleep 10 & time srun -n 1 echo ok
[1] 2734
[2] 2735
ok
[1]-  Done                    srun -n 1 sleep 10
[2]+  Done                    srun -n 1 sleep 10

real    0m10.201s
user    0m0.072s
sys 0m0.028s

您可以看到，简单的

echo

花费了10秒，因为第三个

srun

必须等到前两个完成，因为分配只有两个核心