bash 명령으로 CPU 스파이크를 만드는 방법

Linux 컴퓨터에서 거의 100 %로드를 만들고 싶습니다. 쿼드 코어 시스템이며 모든 코어가 최고 속도로 가고 싶습니다. 이상적으로 CPU로드는 지정된 시간 동안 지속 된 다음 중지됩니다. 나는 bash에 약간의 트릭이 있기를 바라고있다. 나는 일종의 무한 루프를 생각하고 있습니다.

당신은 또한 할 수 있습니다

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 개 스레드)만큼 중괄호 안에 명령을 반복하십시오. 간단한 Enter 키를 누르면 중지됩니다 (이 사용자에서 다른 dd가 실행되고 있지 않은지 확인하십시오).

나는 이런 종류의 일에 스트레스 를 사용 합니다. 최대 코어 수를 알려줄 수 있습니다. 메모리와 디스크에 스트레스를 줄 수 있습니다.

60 초 동안 2 개의 코어에 응력을 가하는 예

stress --cpu 2 --timeout 60

나는 이것이 더 간단하다고 생각합니다. 터미널을 열고 다음을 입력하고 Enter를 누르십시오.

yes > /dev/null &

최신 CPU를 완전히 활용하려면 한 줄로는 충분하지 않으므로 모든 CPU 전원을 소모하기 위해 명령을 반복해야 할 수도 있습니다.

이 모든 것을 끝내려면 간단히

killall yes

이 아이디어는 Mac 사용자를위한 것이지만 원래 여기 에서 발견 되었지만 * nix에도 적용됩니다.

나는 파티에 늦었지만이 게시물은 구글 검색에서 "리눅스에서 부하 생성"의 최고 결과 중 하나이다.

솔루션으로 표시된 결과는 시스템 부하를 생성하는 데 사용될 수 있습니다. 나는 sha1sum /dev/zeroCPU 코어에 부하를 가하는 데 선호합니다 .

아이디어는 무한 데이터 스트림 (예 : / dev / zero, / dev / urandom 등)에서 해시 합계를 계산하는 것입니다.이 프로세스는 프로세스가 중단 될 때까지 CPU 코어를 최대한으로 사용하려고 시도합니다. 더 많은 코어에 대한로드를 생성하기 위해 여러 명령을 함께 파이프 할 수 있습니다.

예. 2 코어로드 생성 : sha1sum /dev/zero | sha1sum /dev/zero

하나의 핵심 (외부 프로세스를 호출하지 않음) :

while true; do true; done

두 가지 핵심 :

while true; do /bin/true; done

후자는 내 둘 다 ~ 50 %로 이동합니다 ...

이것은 둘 다 100 %로 만들 것입니다 :

while true; do echo; done

5 초 동안 3 개의 코어를로드하려면 :

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

이로 인해 많은 write () 시스템 호출에서 높은 커널 (sys)로드가 발생합니다.

대부분 userland CPU로드를 선호하는 경우 :

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

Ctrl-C를 누를 때까지로드를 계속하려면 다음을 수행하십시오.

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

여기에서 다운로드 할 수있는 프로그램입니다 여기에

Linux 시스템에 쉽게 설치

./configure
make
make install

간단한 명령 줄에서 실행

stress -c 40

sqrt무작위로 생성 된 숫자에 대해 복잡한 계산을 실행하는 40 개의 스레드로 모든 CPU에 스트레스를줍니다 .

프로그램의 타임 아웃을 정의 할 수도 있습니다

stress -c 40 -timeout 10s

dd명령을 사용 하여 제안 된 솔루션과 달리 본질적 IO으로 데이터를 처리하기 때문에 시스템을 실제로 오버로드하지는 않습니다.

스트레스 프로그램은 계산을 다루기 때문에 실제로 시스템에 과부하를줍니다.

:(){ :|:& };:

이 포크 폭탄은 CPU에 혼란을 유발하고 컴퓨터를 손상시킬 수 있습니다.

무한 루프는 내가 가진 아이디어입니다. 이상하게 보이는 것은 :

while :; do :; done

( :와 동일하고 true아무것도하지 않고 0으로 종료합니다)

서브 쉘에서 호출하여 백그라운드에서 실행할 수 있습니다. 그렇게하는 $num_cores것으로 충분합니다. 당신이 그들 모두를 죽일 수 원하는 시간 수면 후와 PID를 얻을 수 jobs -p(힌트 : xargs)

나는 두 가지 스크립트로 나눌 것입니다 :

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

cat /dev/urandom > /dev/null

#!/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

나는 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)

이 방법은 강력하지만 시스템 친화적 인 것처럼 보입니다 .이를 사용하여 시스템을 충돌시킨 적이 없습니다.

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

나는 인터넷을 통해 비슷한 것을 발견 했고이 매우 편리한 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

여기에 언급 된 예제를 사용하지만 IRC의 도움을 받아 자체 CPU 스트레스 테스트 스크립트를 개발했습니다. 스레드 당 서브 쉘과 무한 루프 기술을 사용합니다. 대화식으로 스레드 수와 시간을 지정할 수도 있습니다.

#!/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

여기에서 아이디어를 활용하고 설정된 기간 후에 자동으로 종료되는 코드를 만들면 프로세스를 죽일 필요가 없습니다.

#!/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

이것은 나를 위해 속임수를 쓴다 :

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

bash를 제외하고는 아무것도 사용하지 않습니다.

dimba의 답변을 향상시키고 더 플러그 가능한 것을 제공하려면 (유사한 것이 필요했기 때문에). dd로드 업 개념을 사용하여 다음을 작성했습니다.

현재 코어를 확인하고 많은 dd 스레드를 만듭니다. Enter를 사용하여 코어로드 시작 및 종료

#!/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

나는 몇 가지 답변을 결합하고 사용 가능한 모든 CPU에 스트레스를 확장하는 방법을 추가했습니다.

#!/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

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는 프로세스가 몇 초 밖에 걸리지 않았는지 알기에 충분히 현명하며 시간 창을 적절히 조정합니다. 따라서이 명령을 사용하여 결과를 즉시 볼 수 있습니다.

부하를 늘리거나 CPU 100 %를 소비

sha1sum /dev/zero &

다음 명령을 입력하여 CPU 사용을 볼 수 있습니다

top

하중을 풀기 위해

killall sha1sum

이 나쁜 소년을 리눅스를 실행하는 서버의 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