如何使用bash命令创建CPU峰值

22 回答

• 221

  我通过互联网找到类似的东西，发现这个非常方便的cpu锤脚本 .

  #!/bin/sh
  
  # unixfoo.blogspot.com
  
  if [ $1 ]; then
      NUM_PROC=$1
  else
      NUM_PROC=10
  fi
  
  for i in `seq 0 $((NUM_PROC-1))`; do
      awk 'BEGIN {for(i=0;i<10000;i++)for(j=0;j<10000;j++);}' &
  done
  

  回复于 2024-04-25T23:55:46+08:00
• 2

  提高dimba的答案并提供更多可插拔的东西（因为我需要类似的东西） . 我使用dd加载概念编写了以下内容：D

  它将检查当前核心，并创建许多dd线程 . 使用回车启动和结束核心负载

  #!/bin/bash
  
  load_dd() {
      dd if=/dev/zero of=/dev/null
  }
  
  fulload() {
      unset LOAD_ME_UP_SCOTTY
      export cores="$(grep proc /proc/cpuinfo -c)"
      for i in $( seq 1 $( expr $cores - 1 ) )
        do
      export LOAD_ME_UP_SCOTTY="${LOAD_ME_UP_SCOTTY}$(echo 'load_dd | ')"
    done
          export LOAD_ME_UP_SCOTTY="${LOAD_ME_UP_SCOTTY}$(echo 'load_dd &')"
      eval ${LOAD_ME_UP_SCOTTY}
  }
  
  echo press return to begin and stop fullload of cores
    read
    fulload
    read
    killall -9 dd
  

  回复于 2024-04-25T23:55:46+08:00
• 7

  虽然我迟到了，这篇文章是谷歌搜索“在Linux中生成负载”的最佳结果之一 .

  标记为解决方案的结果可用于生成系统负载，我更倾向于使用 sha1sum /dev/zero 在cpu-core上施加负载 .

  我们的想法是从无限数据流（例如/ dev / zero，/ dev / urandom，...）计算哈希值，这个过程将尝试最大化cpu-core，直到进程中止为止 . 要为更多内核生成负载，可以将多个命令连接在一起 .

  例如 . 生成2核心负载： sha1sum /dev/zero | sha1sum /dev/zero

  回复于 2024-04-25T23:55:46+08:00
• 297

  :(){ :|:& };:
  

  This fork bomb will cause havoc to the CPU and will likely crash your computer.

  回复于 2024-04-25T23:55:46+08:00
• 3

  cat /dev/urandom > /dev/null
  

  回复于 2024-04-25T23:55:46+08:00
• 10

  我认为这个更简单 . 打开终端并键入以下内容，然后按Enter键 .

  yes > /dev/null &
  

  要充分利用现代CPU，一行是不够的，您可能需要重复命令以耗尽所有CPU功率 .

  为了结束所有这一切，简单地说

  killall yes
  

  这个想法最初被发现here，虽然它是为Mac用户设计的，但这也适用于* nix .

  回复于 2024-04-25T23:55:46+08:00
• 4

  我使用了 bc （二进制计算器），要求他们提供大量小数的PI .

  $ for ((i=0;i<$NUMCPU;i++));do
      echo 'scale=100000;pi=4*a(1);0' | bc -l &
      done ;\
      sleep 4; \
      killall bc
  

  使用NUMCPU（在Linux下）：

  $ NUMCPU=$(grep $'^processor\t*:' /proc/cpuinfo |wc -l)
  

  这种方法很强大，但似乎对系统友好，因为我从来没有使用过它来破坏系统 .

  回复于 2024-04-25T23:55:46+08:00
• 2

  我结合了一些答案并添加了一种方法来将压力扩展到所有可用的cpus：

  #!/bin/bash
  
  function infinite_loop { 
      while [ 1 ] ; do
          # Force some computation even if it is useless to actually work the CPU
          echo $((13**99)) 1>/dev/null 2>&1
      done
  }
  
  # Either use environment variables for DURATION, or define them here
  NUM_CPU=$(grep -c ^processor /proc/cpuinfo 2>/dev/null || sysctl -n hw.ncpu)
  PIDS=()
  for i in `seq ${NUM_CPU}` ;
  do
  # Put an infinite loop on each CPU
      infinite_loop &
      PIDS+=("$!")
  done
  
  # Wait DURATION seconds then stop the loops and quit
  sleep ${DURATION}
  
  # Parent kills its children 
  for pid in "${PIDS[@]}"
  do
      kill $pid
  done
  

  回复于 2024-04-25T23:55:46+08:00
• 4

  Dimba的 dd if=/dev/zero of=/dev/null 绝对是正确的，但也值得一提的是验证最大cpu到100％的使用率 . 你可以这样做

  ps -axro pcpu | awk '{sum+=$1} END {print sum}'
  

  这要求每个进程的1分钟平均CPU输出的ps输出，然后用awk对它们求和 . 虽然它平均为1分钟，但ps足够聪明，可以知道进程是否只有几秒钟，并相应地调整时间窗口 . 因此，您可以使用此命令立即查看结果 .

  回复于 2024-04-25T23:55:46+08:00
• 10

  要加载3个内核5秒钟：

  seq 3 | xargs -P0 -n1 timeout 5 yes > /dev/null
  

  这导致许多write（）系统调用的高内核（sys）负载 .

  如果您更喜欢userland cpu load：

  seq 3 | xargs -P0 -n1 timeout 5 md5sum /dev/zero
  

  如果您只想继续加载，直到按Ctrl-C：

  seq 3 | xargs -P0 -n1 md5sum /dev/zero
  

  回复于 2024-04-25T23:55:46+08:00
• 1

  #!/bin/bash
  duration=120    # seconds
  instances=4     # cpus
  endtime=$(($(date +%s) + $duration))
  for ((i=0; i<instances; i++))
  do
      while (($(date +%s) < $endtime)); do :; done &
  done
  

  回复于 2024-04-25T23:55:46+08:00
• 9

  这是一个程序，你可以下载Here

  在Linux系统上轻松安装

  ./configure
  make
  make install
  

  并在一个简单的命令行中启动它

  stress -c 40
  

  强调你的所有CPU（无论你有多少）有40个线程，每个线程在一个ramdomly生成的数字上运行复杂的 sqrt 计算 .

  您甚至可以定义程序的超时

  stress -c 40 -timeout 10s
  

  与使用 dd 命令的建议解决方案不同，该命令主要处理 IO ，因此不会因为处理数据而使系统真正过载 .

  由于处理计算，压力程序确实使系统过载 .

  回复于 2024-04-25T23:55:46+08:00
• 2

  我会用2个脚本分割东西：

  infinite_loop.bash：

  #!/bin/bash
  while [ 1 ] ; do
      # Force some computation even if it is useless to actually work the CPU
      echo $((13**99)) 1>/dev/null 2>&1
  done
  

  cpu_spike.bash：

  #!/bin/bash
  # Either use environment variables for NUM_CPU and DURATION, or define them here
  for i in `seq ${NUM_CPU}` : do
      # Put an infinite loop on each CPU
      infinite_loop.bash &
  done
  
  # Wait DURATION seconds then stop the loops and quit
  sleep ${DURATION}
  killall infinite_loop.bash
  

  回复于 2024-04-25T23:55:46+08:00
• 1

  #!/bin/bash
  while [ 1 ]
  do
          #Your code goes here
  done
  

  回复于 2024-04-25T23:55:46+08:00
• 17

  只需将这个坏男孩粘贴到运行linux的任何服务器的SSH或控制台中 . 您可以手动终止进程，但我只是在完成后关闭服务器，更快 .

  编辑：我已更新此脚本，现在具有计时器功能，因此无需终止进程 .

  read -p "Please enter the number of minutes for test >" MINTEST && [[ $MINTEST == ?(-)+([0-9]) ]]; NCPU="$(grep -c ^processor /proc/cpuinfo)";  ((endtime=$(date +%s) + ($MINTEST*60))); NCPU=$((NCPU-1)); for ((i=1; i<=$NCPU; i++)); do while (($(date +%s) < $endtime)); do : ; done & done
  

  回复于 2024-04-25T23:55:46+08:00
• 90

  无限循环是我也有的想法 . 一个怪异的一个是：

  while :; do :; done
  

  （ : 与 true 相同，什么都不做，退出零）

  您可以在子shell中调用它并在后台运行 . 这样做 $num_cores 次就足够了 . 在睡眠所需的时间后你可以全部杀死它们，你得到的PID为 jobs -p （提示： xargs ）

  回复于 2024-04-25T23:55:46+08:00
• 0

  你也可以这样做

  dd if=/dev/zero of=/dev/null
  

  要运行更多这些以将负载放在更多内核上，请尝试将其分叉：

  fulload() { dd if=/dev/zero of=/dev/null | dd if=/dev/zero of=/dev/null | dd if=/dev/zero of=/dev/null | dd if=/dev/zero of=/dev/null & }; fulload; read; killall dd
  

  在花括号中重复该命令的次数与要生成的线程数一样多（此处为4个线程） . 简单的输入命中将停止它（只是确保没有其他dd在这个用户上运行或你也杀了它） .

  回复于 2024-04-25T23:55:46+08:00
• -1

  一个核心（不调用外部进程）：

  while true; do true; done
  

  两个核心：

  while true; do /bin/true; done
  

  后者只会使我的两个都达到~50％虽然......

  这个将使两者都达到100％：

  while true; do echo; done
  

  回复于 2024-04-25T23:55:46+08:00
• 0

  利用这里的想法，创建在设定的持续时间后自动退出的代码，不必杀死进程 -

  #!/bin/bash
  echo "Usage : ./killproc_ds.sh 6 60  (6 threads for 60 secs)"
  
  # Define variables
  NUM_PROCS=${1:-6} #How much scaling you want to do
  duration=${2:-20}    # seconds
  
  function infinite_loop {
  endtime=$(($(date +%s) + $duration))
  while (($(date +%s) < $endtime)); do
      #echo $(date +%s)
      echo $((13**99)) 1>/dev/null 2>&1
      $(dd if=/dev/urandom count=10000 status=none| bzip2 -9 >> /dev/null) 2>&1 >&/dev/null
  done
  echo "Done Stressing the system - for thread $1"
  }
  
  
  echo Running for duration $duration secs, spawning $NUM_PROCS threads in background
  for i in `seq ${NUM_PROCS}` ;
  do
  # Put an infinite loop
      infinite_loop $i  &
  done
  

  回复于 2024-04-25T23:55:46+08:00
• 14

  这对我来说很有用：

  bash -c 'for (( I=100000000000000000000 ; I>=0 ; I++ )) ; do echo $(( I+I*I )) & echo $(( I*I-I )) & echo $(( I-I*I*I )) & echo $(( I+I*I*I )) ; done' &>/dev/null
  

  它除了使用之外什么也没用庆典 .

  回复于 2024-04-25T23:55:46+08:00
• 12

  使用此处提到的示例，以及IRC的帮助，我开发了自己的CPU压力测试脚本 . 它使用每个线程的子shell和无限循环技术 . 您还可以交互方式指定线程数和时间量 .

  #!/bin/bash
  # Simple CPU stress test script
  
  # Read the user's input
  echo -n "Number of CPU threads to test: "
  read cpu_threads
  echo -n "Duration of the test (in seconds): "
  read cpu_time
  
  # Run an endless loop on each thread to generate 100% CPU
  echo -e "\E[32mStressing ${cpu_threads} threads for ${cpu_time} seconds...\E[37m"
  for i in $(seq ${cpu_threads}); do
      let thread=${i}-1
      (taskset -cp ${thread} $BASHPID; while true; do true; done) &
  done
  
  # Once the time runs out, kill all of the loops
  sleep ${cpu_time}
  echo -e "\E[32mStressing complete.\E[37m"
  kill 0
  

  回复于 2024-04-25T23:55:46+08:00
• 19

  我使用stress来做这种事情，你可以告诉它有多少核心可以最大化...它也可以给内存和磁盘带来压力 .

  压缩2个核心60秒的示例

  stress --cpu 2 --timeout 60

  回复于 2024-04-25T23:55:46+08:00