主页 / unix / 问题

问题[jobs](unix)

Martin Hope
Maskim
Asked: 2021-09-02 05:55:10 +0800 CST
  • 1

我正在和一些人一起工作tail -f path/to/my/log/file | grep pattern&，我需要尽快终止这个过程。使用 classickill {tail PID}时，tail 仍会显示其缓冲区，并且大约需要 12 秒（在我的设置中）才能让 tail 完全静音。

kill %{job id}但是，当我用它杀死它时（略多于一秒）它会快得多。

调用kill {tail PID}and有什么不同kill %{job id}？

一些样品：

01/09/2021 15:45:29:670:kill {tail PID}
...
01/09/2021 15:45:39:232: {some log}
01/09/2021 15:45:39:232: {some log}
01/09/2021 15:45:39:232: {last log line}  
takes around 10 seconds to fully shutdown

使用 kill %{job id} ：

01/09/2021 10:56:57:793 -> (COM12<):kill %{tail job ID}
...
01/09/2021 10:56:58:966 -> (COM12>):[root@my_board ~]# 
takes 1 sec to fully shutdown
jobs job-control
Martin Hope
bUff23
Asked: 2020-01-09 19:11:58 +0800 CST
  • 0

我有一个作为作业运行的 fio 工作负载。

FIO 工作量：

---

kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: fio-target
spec:
  #storageClassName: ocs-storagecluster-cephfs
  storageClassName: ocs-storagecluster-ceph-rbd
  accessModes: ["ReadWriteOnce"]
  resources:
    requests:
      storage: 50Gi

---

kind: ConfigMap
apiVersion: v1
metadata:
  name: fio-config
data: 
  workload.fio: |
    [simple-write]
    readwrite=write
    buffered=1
    blocksize=4k
    ioengine=libaio
    directory=/target
    #size=10G
    fill_fs=1

---

apiVersion: batch/v1
kind: Job
metadata:
  name: fio
spec:
  template:
    metadata:
      name: fio
    spec:
      containers:
        - name: fio
          image: quay.io/johnstrunk/fs-performance:latest
          command:
            - "/usr/bin/fio"
            - "--output-format=json"
            - "/etc/fio/workload.fio"
          volumeMounts:
            - name: target
              mountPath: /target
            - name: fio-config-volume
              mountPath: /etc/fio
      restartPolicy: Always
      volumes:
        - name: target
          persistentVolumeClaim:
            claimName: fio-target
        - name: fio-config-volume
          configMap:
            name: fio-config

fio工作量的输出：

fio: io_u error on file /target/simple-write.0.0: No space left on device: write offset=52638969856, buflen=4096
{
  "fio version" : "fio-3.7",
  "timestamp" : 1578468421,
  "timestamp_ms" : 1578468421512,
  "time" : "Wed Jan  8 07:27:01 2020",
  "jobs" : [
    {
      "jobname" : "simple-write",
      "groupid" : 0,
      "error" : 0,
      "eta" : 0,
      "elapsed" : 149,
      "job options" : {
        "rw" : "write",
        "buffered" : "1",
        "bs" : "4k",
        "ioengine" : "libaio",
        "directory" : "/target",
        "fill_device" : "1"
      },
      "read" : {
        "io_bytes" : 0,
        "io_kbytes" : 0,
        "bw_bytes" : 0,
        "bw" : 0,
        "iops" : 0.000000,
        "runtime" : 0,
        "total_ios" : 0,
        "short_ios" : 0,
        "drop_ios" : 0,
        "slat_ns" : {
          "min" : 0,
          "max" : 0,
          "mean" : 0.000000,
          "stddev" : 0.000000
        },
        "clat_ns" : {
          "min" : 0,
          "max" : 0,
          "mean" : 0.000000,
          "stddev" : 0.000000,
          "percentile" : {
            "1.000000" : 0,
            "5.000000" : 0,
            "10.000000" : 0,
            "20.000000" : 0,
            "30.000000" : 0,
            "40.000000" : 0,
            "50.000000" : 0,
            "60.000000" : 0,
            "70.000000" : 0,
            "80.000000" : 0,
            "90.000000" : 0,
            "95.000000" : 0,
            "99.000000" : 0,
            "99.500000" : 0,
            "99.900000" : 0,
            "99.950000" : 0,
            "99.990000" : 0
          }
        },
        "lat_ns" : {
          "min" : 0,
          "max" : 0,
          "mean" : 0.000000,
          "stddev" : 0.000000
        },
        "bw_min" : 0,
        "bw_max" : 0,
        "bw_agg" : 0.000000,
        "bw_mean" : 0.000000,
        "bw_dev" : 0.000000,
        "bw_samples" : 0,
        "iops_min" : 0,
        "iops_max" : 0,
        "iops_mean" : 0.000000,
        "iops_stddev" : 0.000000,
        "iops_samples" : 0
      },
      "write" : {
        "io_bytes" : 52638969856,
        "io_kbytes" : 51405244,
        "bw_bytes" : 355971772,
        "bw" : 347628,
        "iops" : 86907.177732,
        "runtime" : 147874,
        "total_ios" : 12851312,
        "short_ios" : 0,
        "drop_ios" : 0,
        "slat_ns" : {
          "min" : 2123,
          "max" : 1877670923,
          "mean" : 10619.164491,
          "stddev" : 1295004.136689
        },
        "clat_ns" : {
          "min" : 559,
          "max" : 503883,
          "mean" : 597.424963,
          "stddev" : 334.725902,
          "percentile" : {
            "1.000000" : 572,
            "5.000000" : 572,
            "10.000000" : 572,
            "20.000000" : 580,
            "30.000000" : 580,
            "40.000000" : 580,
            "50.000000" : 580,
            "60.000000" : 588,
            "70.000000" : 588,
            "80.000000" : 588,
            "90.000000" : 596,
            "95.000000" : 604,
            "99.000000" : 780,
            "99.500000" : 868,
            "99.900000" : 1976,
            "99.950000" : 7392,
            "99.990000" : 11968
          }
        },
        "lat_ns" : {
          "min" : 2750,
          "max" : 1877675884,
          "mean" : 11260.353627,
          "stddev" : 1295013.364993
        },
        "bw_min" : 8,
        "bw_max" : 1046704,
        "bw_agg" : 100.000000,
        "bw_mean" : 369150.841727,
        "bw_dev" : 237962.484144,
        "bw_samples" : 278,
        "iops_min" : 2,
        "iops_max" : 261676,
        "iops_mean" : 92287.737410,
        "iops_stddev" : 59490.597358,
        "iops_samples" : 278
      },
      "trim" : {
        "io_bytes" : 0,
        "io_kbytes" : 0,
        "bw_bytes" : 0,
        "bw" : 0,
        "iops" : 0.000000,
        "runtime" : 0,
        "total_ios" : 0,
        "short_ios" : 0,
        "drop_ios" : 0,
        "slat_ns" : {
          "min" : 0,
          "max" : 0,
          "mean" : 0.000000,
          "stddev" : 0.000000
        },
        "clat_ns" : {
          "min" : 0,
          "max" : 0,
          "mean" : 0.000000,
          "stddev" : 0.000000,
          "percentile" : {
            "1.000000" : 0,
            "5.000000" : 0,
            "10.000000" : 0,
            "20.000000" : 0,
            "30.000000" : 0,
            "40.000000" : 0,
            "50.000000" : 0,
            "60.000000" : 0,
            "70.000000" : 0,
            "80.000000" : 0,
            "90.000000" : 0,
            "95.000000" : 0,
            "99.000000" : 0,
            "99.500000" : 0,
            "99.900000" : 0,
            "99.950000" : 0,
            "99.990000" : 0
          }
        },
        "lat_ns" : {
          "min" : 0,
          "max" : 0,
          "mean" : 0.000000,
          "stddev" : 0.000000
        },
        "bw_min" : 0,
        "bw_max" : 0,
        "bw_agg" : 0.000000,
        "bw_mean" : 0.000000,
        "bw_dev" : 0.000000,
        "bw_samples" : 0,
        "iops_min" : 0,
        "iops_max" : 0,
        "iops_mean" : 0.000000,
        "iops_stddev" : 0.000000,
        "iops_samples" : 0
      },
      "sync" : {
        "lat_ns" : {
          "min" : 0,
          "max" : 0,
          "mean" : 0.000000,
          "stddev" : 0.000000,
          "percentile" : {
            "1.000000" : 0,
            "5.000000" : 0,
            "10.000000" : 0,
            "20.000000" : 0,
            "30.000000" : 0,
            "40.000000" : 0,
            "50.000000" : 0,
            "60.000000" : 0,
            "70.000000" : 0,
            "80.000000" : 0,
            "90.000000" : 0,
            "95.000000" : 0,
            "99.000000" : 0,
            "99.500000" : 0,
            "99.900000" : 0,
            "99.950000" : 0,
            "99.990000" : 0
          }
        },
        "total_ios" : 0
      },
      "usr_cpu" : 8.353114,
      "sys_cpu" : 27.498597,
      "ctx" : 9500,
      "majf" : 0,
      "minf" : 20,
      "iodepth_level" : {
        "1" : 100.000000,
        "2" : 0.000000,
        "4" : 0.000000,
        "8" : 0.000000,
        "16" : 0.000000,
        "32" : 0.000000,
        ">=64" : 0.000000
      },
      "latency_ns" : {
        "2" : 0.000000,
        "4" : 0.000000,
        "10" : 0.000000,
        "20" : 0.000000,
        "50" : 0.000000,
        "100" : 0.000000,
        "250" : 0.000000,
        "500" : 0.000000,
        "750" : 98.191811,
        "1000" : 1.513962
      },
      "latency_us" : {
        "2" : 0.197637,
        "4" : 0.019383,
        "10" : 0.060476,
        "20" : 0.012987,
        "50" : 0.010000,
        "100" : 0.010000,
        "250" : 0.010000,
        "500" : 0.000000,
        "750" : 0.010000,
        "1000" : 0.000000
      },
      "latency_ms" : {
        "2" : 0.000000,
        "4" : 0.000000,
        "10" : 0.000000,
        "20" : 0.000000,
        "50" : 0.000000,
        "100" : 0.000000,
        "250" : 0.000000,
        "500" : 0.000000,
        "750" : 0.000000,
        "1000" : 0.000000,
        "2000" : 0.000000,
        ">=2000" : 0.000000
      },
      "latency_depth" : 1,
      "latency_target" : 0,
      "latency_percentile" : 100.000000,
      "latency_window" : 0
    }
  ],
  "disk_util" : [
    {
      "name" : "rbd0",
      "read_ios" : 35,
      "write_ios" : 9010,
      "read_merges" : 0,
      "write_merges" : 9085,
      "read_ticks" : 20979,
      "write_ticks" : 23182697,
      "in_queue" : 23199138,
      "util" : 5.652565
    }
  ]
}

我不明白为什么这份工作要求更多的空间？运行此作业后，我看不到“kubelet_volume_stats_used_bytes”指标下列出的任何 fio PVC。

看到集群上使用的存储空间从 0.4 GB 增加到 148 GB 也很奇怪。

据我所知，有人可以解释一下它应该只使用 50GB 吗？

command jobs
Martin Hope
czerny
Asked: 2018-12-15 02:56:40 +0800 CST
  • 23

我正在寻找类似的东西，command1 ; command2即如何运行command2，command1但我想计划执行command2何时command1已经运行。

只需键入command2并通过 Enter 确认即可解决，假设command1不消耗标准输入，并且command1不会在输出中产生太多文本，因此键入不切实际（键入的字符与command1输出混合）。

bash jobs job-control
Martin Hope
mf94
Asked: 2018-08-22 08:55:08 +0800 CST
  • 0

我有一个大型脚本，它依赖于输入参数（使用 getopts）。其中一个参数是一个包含文件的目录（所有文件都命名为 *bam） 这个脚本有两个部分：

  • Part1：根据输入的*bam文件，计算一个具体的数字。需要明确的是，结果是一个数字，而不是每个文件一个数字。
  • 第 2 部分：使用第 1 部分中找到的编号，对每个 *bam 文件执行一系列操作。

现在，从计算的角度来看，part1 最初非常快。所以我的设置是：

  • 在终端上运行脚本：bash script.sh
  • 在 script.sh 中，对于第 2 部分，为每个文件提交 HPC 作业

然而，现在我需要分析比原计划更多的文件，我意识到第 1 部分的计算量也很大——因此我还需要在 HPC 上运行它。

所以我的问题是：

  • 是否可以提交在其中提交作业的 HPC 作业？
  • 换句话说，我可以将 script.sh 作为作业提交，并且仍然让它在第 2 部分中提交作业吗？

明确地说，这是我的脚本的示例：

#!/usr/bin/bash

# PART 0: accept all input arguments

USAGE() { echo "Usage: bash $0 [-b <in-bam-files-dir>] [-o <out-dir>] [-c <chromlen>]" 1>&2; exit 1; }

if (($# == 0)); then
        USAGE
fi

# Use getopts to accept each argument

while getopts ":b:o:c:h" opt
do
    case $opt in
       b ) BAMFILES=$OPTARG
        ;;
       o ) OUTDIR=$OPTARG
        ;;
       c ) CHROMLEN=$OPTARG
        ;;
       h ) USAGE
        ;;
       \? ) echo "Invalid option: -$OPTARG exiting" >&2
        exit
        ;;
       : ) echo "Option -$OPTARG requires an argument" >&2
        exit
        ;;
        esac
    done

# PART1: calculate this unique number

NUMBER=0    

for i in  $(ls $BAMFILES/*.bam)
do
  make some calculations on each file to obtain a number ...
  keep only the smallest found number and assign its value to $NUMBER
done

echo "Final number is ${NUMBER} "

# PART2: Using $NUMBER that we found above, submit a job for each *bam file

for i in $(ls $BAMFILES/*bam)
do

    if [ ! -f ${OUTDIR}/${SAMPLE}.bw ];
    then 
        command=" command -options -b $NUMBER $i"

    echo $command | qsub -V -cwd -o $OUTDIR -e $OUTDIR -l tmem=6G -l h_vmem=6G -l h_rt=3600 -N result_${SAMPLE}

    fi

done
jobs getopts
Martin Hope
dksadmsaklaslksald
Asked: 2018-06-18 15:19:22 +0800 CST
  • 2

我有一个脚本叫做go.sh

python3 bob.py &> lol.log & 
python3 alice.py &> lol2.log &

当我运行./go.sh然后运行jobs​​. 我执行的任何一项工作都没有go.sh出现在jobs. 事实上，什么都没有出现在jobs.

然而，当我逐个运行每个命令时go.sh，它确实出现在jobs.

我怎样才能解决这个问题？

linux jobs
Martin Hope
user88036
Asked: 2018-03-08 14:06:37 +0800 CST
  • 1

我有一个分析程序和一个包含数据的文本文件，为了便于说明，我将分别调用wibble和data.txt。

我尝试了一个简单的for循环来处理我的所有数据：

对于我在 $(cat data.txt); 做
    颤抖 $i
完毕

但要一一完成分析，需要很长的时间。

所以我试着让它为每个数据分拆单独的工作：

对于我在 $(cat data.txt); 做
    ( wibb $i ) &
完毕

但是运行这么多分析进程会导致内存崩溃！

所以我想以五人一组的方式启动分析过程。我想获取前五个数据项，对它们进行分析；然后拿下五个并做同样的事情；等等。

如前一篇文章（下文）所述，如果不使用“并行”程序，我该如何做到这一点？我的机构工作站上没有 sudo 权限来安装此应用程序，因此我正在尝试使用更简单的代码来实现这一目标。

https://unix.stackexchange.com/questions/299346/running-commands-at-once
https://unix.stackexchange.com/questions/361505/how-to-control-for-loop
bash jobs
Martin Hope
hengyue li
Asked: 2018-01-15 18:58:05 +0800 CST
  • 1

我在一台电脑（实际上是几台电脑）上进行了一些科学计算，我想知道一次应该提交多少份工作。lscpu 显示：

CPU(s):                8
On-line CPU(s) list:   0-7
Thread(s) per core:    2
Core(s) per socket:    4
Socket(s):             1

歧义是“线程”。我搜索了网络并了解了一些相关信息。但是我还是觉得很困惑（据说要提交多少工作取决于）。我不关心机器的细节。例如，现在我有一个可执行文件。如果我直接运行它，它会花费大约 10 分钟。假设现在我有 800 个需要运行。我应该一次运行 4 个还是 8 个以降低总时间成本？

cpu jobs