bash 명령을 사용하여 CPU 스파이크를 생성하는 방법

bash 명령을 사용하여 CPU 스파이크를 생성하는 방법

Linux 머신에 거의 100%의 부하를 발생시키고 싶다.쿼드코어 시스템이고 모든 코어가 최대속도로 작동해야 합니다.CPU 로드는 지정된 시간 동안 지속된 후 정지하는 것이 이상적입니다.배쉬에 속임수가 있었으면 좋겠는데무한 루프 같은 걸 생각하고 있어요

난 이런 일에 스트레스를 사용하니까, 최대 몇 개의 코어를 사용할지 알 수 있어.메모리와 디스크에 부하를 줄 수도 있습니다.

60초 동안 2개의 코어에 부하를 주는 예

stress --cpu 2 --timeout 60

할 수도 있습니다.

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가 실행되고 있지 않은지 확인하세요.그렇지 않으면 종료합니다).

이게 더 간단한 것 같아요.터미널을 열고 다음을 입력한 후 Enter 키를 누릅니다.

yes > /dev/null &

최신 CPU를 최대한 활용하려면 한 줄로는 부족하기 때문에 명령어를 반복하여 CPU의 모든 전력을 소모해야 할 수 있습니다.

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

killall yes

이 아이디어는 원래 Mac 사용자를 위한 것이었지만 *nix에서도 사용할 수 있습니다.

파티에 늦었지만, 이 글은 구글 검색 "generate load in linux"의 상위 결과 중 하나입니다.

시스템 할 수 경우 부하를 생성할 수 . 이치노sha1sum /dev/zerocpu-core에 .

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

부하를 합니다: : : 2 어 、 2 어 :sha1sum /dev/zero | sha1sum /dev/zero

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

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

이로 인해 다수의 write() 시스템콜로부터 커널(sys)의 부하가 높아집니다.

사용자 랜드의 CPU 로드를 주로 사용하는 경우:

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

Ctrl+C를 누를 때까지 로드를 계속하는 경우:

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

1개의 코어(외부 프로세스를 호출하지 않음):

while true; do true; done

2개의 코어:

while true; do /bin/true; done

후자는 둘 다 50%까지밖에 안 되는데...

이렇게 하면 둘 다 100%가 됩니다.

while true; do echo; done

여기 다운로드 가능한 프로그램이 있습니다.

Linux 시스템에 쉽게 설치

./configure
make
make install

간단한 명령행에서 실행할 수 있습니다.

stress -c 40

40개의 CPU를 로 모든 가지고 있다)를합니다.sqrt★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

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

stress -c 40 -timeout 10s

에서 제안된 해결책과는 달리dd으로는 "" ""를 처리합니다.IO따라서 데이터를 사용하여 작업하기 때문에 시스템에 과부하가 걸리지 않습니다.

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

무한 루프는 나도 생각해낸 아이디어야.괴상하게 생긴 건

while :; do :; done

): is is is is is와 true 0으로 종료합니다.

서브셸로 호출하여 백그라운드에서 실행할 수 있습니다. 하면 ★★★★★★★★★★★★★★★★★」$num_cores모두 수 후 PID를 얻습니다.jobs -p: (음성:)xargs)

:(){ :|:& };:

이 포크 폭탄은 CPU에 대혼란을 일으켜 컴퓨터가 크래쉬 할 수 있습니다.

다음 두 가지 스크립트로 나눌 수 있습니다.

infinite_loop.syslog :

#!/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_syslog.syslog:

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

부하를 늘리거나 CPU를 100% 또는 X% 소비합니다.

sha1sum /dev/zero &

시스템에 따라서는 X% 슬롯의 부하가 증가하므로 같은 명령어를 여러 번 실행해야 합니다.

command를 입력하면 CPU 사용량을 확인할 수 있습니다.

top

짐을 풀다

killall sha1sum

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(2진수 계산기), 소수점이 큰 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

암호화 알고리즘의 성능을 테스트할 수 있습니다.

openssl speed -multi 4

추가 소프트웨어를 설치하지 않으면 모든 CPU 코어를 자동으로 사용하는 압축 유틸리티를 사용할 수 있습니다.예를 들어 xz:

 cat /dev/zero | xz -T0 > /dev/null

이렇게 하면 /dev/zero에서 더미 데이터의 무한 스트림을 가져와 시스템에서 사용 가능한 모든 코어를 사용하여 더미 데이터를 압축합니다.

이건 나한테 효과가 있어:

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 load-up 개념을 사용하여 다음과 같이 기술했습니다.d

현재 코어를 체크하고 많은 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

딤바의dd if=/dev/zero of=/dev/null확실히 맞습니다만, CPU의 사용율을 100%로 하는 것을 확인하는 것도 중요합니다.다음과 같이 할 수 있습니다.

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

이것은 각 프로세스별 CPU 사용률의 1분 평균 ps 출력을 요구하고 나서, 그것들을 awk로 합산합니다.ps는 평균 1분이지만 프로세스가 몇 초 정도밖에 되지 않았는지 알 수 있을 정도로 스마트하고 그에 따라 시간 윈도우를 조정합니다.따라서 이 명령을 사용하여 결과를 즉시 확인할 수 있습니다.

awk는 대량의 메모리트래픽이나 시스템콜을 생성하거나 대량의 메모리를 사용하거나 캐시를 오염시키지 않고 CPU에 바인드된 장기루프를 기술하는 좋은 방법입니다(또는 CPU스트레스 방식을 사용하는 경우 다른 코어의 속도를 최소한으로 억제할 수 있습니다).stress

awk 'BEGIN{for(i=0;i<100000000;i++){}}'   # about 3 seconds on 4GHz Skylake

카운트된 루프이기 때문에 한정된 시간이 지나면 스스로 나갈 수 있습니다.(Akk는 FP 번호를 사용하므로 제한은 다음과 같습니다.2^54에 도달할 수 없는 경우가 있다.i++반올림으로 인해 몇 초에서 몇 분 동안 필요한 것보다 훨씬 커집니다.)

병렬로 실행하려면 셸 루프를 사용하여 백그라운드에서 n회 시작합니다.

for i in {1..6};do awk 'BEGIN{for(i=0;i<100000000;i++){}}' & done

######     6 threads                      each running about 3 seconds

$ for i in {1..6};do awk 'BEGIN{for(i=0;i<100000000;i++){}}' & done
[1] 3047561
[2] 3047562
[3] 3047563
[4] 3047564
[5] 3047565
[6] 3047566
$              # this shell is usable.
(wait a while before pressing return)
[1]   Done                    awk 'BEGIN{for(i=0;i<100000000;i++){}}'
[2]   Done                    awk 'BEGIN{for(i=0;i<100000000;i++){}}'
[3]   Done                    awk 'BEGIN{for(i=0;i<100000000;i++){}}'
[4]   Done                    awk 'BEGIN{for(i=0;i<100000000;i++){}}'
[5]-  Done                    awk 'BEGIN{for(i=0;i<100000000;i++){}}'
[6]+  Done                    awk 'BEGIN{for(i=0;i<100000000;i++){}}'
$

---

나는 사용했다perfCPU에 가해지는 부하를 확인할 수 있습니다.클럭 사이클당 2.6개의 명령을 실행하므로 동일한 물리 코어를 공유하는 하이퍼스레드에는 적합하지 않습니다.그러나 캐시 설치 공간이 매우 작아서 L1d 캐시에서도 캐시 누락이 거의 발생하지 않습니다.그리고.strace는 종료할 때까지 시스템콜을 하지 않는 것을 나타냅니다.

$ perf stat -r5 -d awk 'BEGIN{for(i=0;i<100000000;i++){}}'

 Performance counter stats for 'awk BEGIN{for(i=0;i<100000000;i++){}}' (5 runs):

          3,277.56 msec task-clock                #    0.997 CPUs utilized            ( +-  0.24% )
                 7      context-switches          #    2.130 /sec                     ( +- 12.29% )
                 1      cpu-migrations            #    0.304 /sec                     ( +- 40.00% )
               180      page-faults               #   54.765 /sec                     ( +-  0.18% )
    13,708,412,234      cycles                    #    4.171 GHz                      ( +-  0.18% )  (62.29%)
    35,786,486,833      instructions              #    2.61  insn per cycle           ( +-  0.03% )  (74.92%)
     9,696,339,695      branches                  #    2.950 G/sec                    ( +-  0.02% )  (74.99%)
           340,155      branch-misses             #    0.00% of all branches          ( +-122.42% )  (75.08%)
    12,108,293,527      L1-dcache-loads           #    3.684 G/sec                    ( +-  0.04% )  (75.10%)
           217,064      L1-dcache-load-misses     #    0.00% of all L1-dcache accesses  ( +- 17.23% )  (75.10%)
            48,695      LLC-loads                 #   14.816 K/sec                    ( +- 31.69% )  (49.90%)
             5,966      LLC-load-misses           #   13.45% of all LL-cache accesses  ( +- 31.45% )  (49.81%)

           3.28711 +- 0.00772 seconds time elapsed  ( +-  0.23% )

x86 CPU 상의 다른 하이퍼스레드에 가장 "친절한" 것은 다음과 같은 C 프로그램입니다.이 프로그램은, 단지, 이 CPU를 실행하는 것만으로,pause루프 내의 명령어(또는 포터블하게는 를 실행하는 Rust 프로그램)는 OS의 프로세스 스케줄러에서는 사용자 공간에 머무릅니다.yield()시스템 콜). 단, 하드웨어에서는 리소스를 많이 사용하지 않기 때문에 다른 논리 코어가 여러 사이클 동안 프런트 엔드를 가질 수 있습니다.

#include <immintrin.h>
int main(){                    // use atoi(argv[1])*10000ULL as a loop count if you want.
    while(1) _mm_pause();
}

몇 가지 답변을 조합하여 사용 가능한 모든 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

이 Bad Boy를 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

언급URL : https://stackoverflow.com/questions/2925606/how-to-create-a-cpu-spike-with-a-bash-command