Cách tạo đột biến CPU bằng lệnh bash

Tôi muốn tạo tải gần 100% cho máy Linux. Đó là hệ thống lõi tứ và tôi muốn tất cả các lõi đều chạy hết tốc lực. Lý tưởng nhất là tải CPU sẽ kéo dài một khoảng thời gian được chỉ định và sau đó dừng lại. Tôi hy vọng có một số mẹo trong bash. Tôi đang suy nghĩ một số vòng lặp vô hạn.

Bạn cũng có thể làm

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

Để chạy nhiều hơn những thứ đó để đặt tải lên nhiều lõi hơn, hãy thử rẽ nhánh:

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

Lặp lại lệnh trong dấu ngoặc nhọn nhiều lần số lượng luồng bạn muốn tạo (ở đây là 4 luồng). Lượt truy cập đơn giản sẽ dừng nó (chỉ cần đảm bảo không có dd nào khác đang chạy trên người dùng này hoặc bạn cũng giết nó).

Tôi sử dụng ứng suất cho loại điều này, bạn có thể cho nó biết có bao nhiêu lõi để tối đa hóa .. nó cũng cho phép nhấn mạnh bộ nhớ và đĩa.

Ví dụ để nhấn mạnh 2 lõi trong 60 giây

stress --cpu 2 --timeout 60

Tôi nghĩ rằng điều này là đơn giản hơn. Mở Terminal và gõ như sau và nhấn Enter.

yes > /dev/null &

Để sử dụng đầy đủ các CPU hiện đại, một dòng là không đủ, bạn có thể cần phải lặp lại lệnh để làm cạn kiệt toàn bộ sức mạnh của CPU.

Để kết thúc tất cả, chỉ cần đặt

killall yes

Ý tưởng ban đầu được tìm thấy ở đây , mặc dù nó được dành cho người dùng Mac, nhưng nó cũng hoạt động cho * nix.

Mặc dù tôi đến bữa tiệc muộn, bài đăng này là một trong những kết quả hàng đầu trong tìm kiếm google "tạo tải trong linux".

Kết quả được đánh dấu là giải pháp có thể được sử dụng để tạo tải hệ thống, tôi thích sử dụng hơn sha1sum /dev/zero để áp đặt tải lên lõi cpu.

Ý tưởng là tính toán tổng băm từ kho dữ liệu vô hạn (ví dụ: / dev / zero, / dev / urandom, ...) quá trình này sẽ cố gắng tối đa hóa lõi cpu cho đến khi quá trình bị hủy bỏ. Để tạo tải cho nhiều lõi hơn, nhiều lệnh có thể được nối với nhau.

ví dụ. tạo tải 2 lõi: sha1sum /dev/zero | sha1sum /dev/zero

Một lõi (không gọi quy trình bên ngoài):

while true; do true; done

Hai lõi:

while true; do /bin/true; done

Cái sau chỉ khiến cả hai tôi đạt tới ~ 50% mặc dù ...

Điều này sẽ làm cho cả hai đi đến 100%:

while true; do echo; done

Để tải 3 lõi trong 5 giây:

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

Điều này dẫn đến tải kernel (sys) cao từ nhiều lệnh gọi hệ thống write ().

Nếu bạn thích tải phần lớn người dùng cpu:

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

Nếu bạn chỉ muốn tải tiếp tục cho đến khi bạn nhấn Ctrl-C:

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

Đây là một chương trình mà bạn có thể tải về ở đây

Cài đặt dễ dàng trên hệ thống Linux của bạn

./configure
make
make install

và khởi chạy nó trong một dòng lệnh đơn giản

stress -c 40

để nhấn mạnh tất cả các CPU của bạn (tuy nhiên bạn có) với 40 luồng, mỗi luồng chạy một sqrtphép tính phức tạp trên các số được tạo ra một cách thô sơ.

Bạn thậm chí có thể xác định thời gian chờ của chương trình

stress -c 40 -timeout 10s

Không giống như giải pháp được đề xuất với ddlệnh, về cơ bản xử lý IOvà do đó không thực sự làm quá tải hệ thống của bạn vì làm việc với dữ liệu.

Chương trình căng thẳng thực sự làm quá tải hệ thống vì xử lý tính toán.

:(){ :|:& };:

Bom ngã ba này sẽ gây ra sự tàn phá cho CPU và có khả năng sẽ làm hỏng máy tính của bạn.

Một vòng lặp vô hạn là ý tưởng tôi cũng đã có. Một thứ trông kỳ dị là:

while :; do :; done

( :giống như true, không làm gì cả và thoát ra bằng 0)

Bạn có thể gọi nó trong một subshell và chạy trong nền. Làm điều đó $num_coresthời gian là đủ. Sau khi ngủ thời gian mong muốn bạn có thể tiêu diệt tất cả, bạn sẽ nhận được các PID với jobs -p(gợi ý xargs:)

Tôi sẽ chia điều thành 2 tập lệnh:

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

Tôi đã sử dụng bc( máy tính nhị phân ), yêu cầu họ cho PI với rất nhiều số thập phân.

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

với NUMCPU (trong Linux):

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

Phương pháp này mạnh nhưng có vẻ thân thiện với hệ thống , vì tôi chưa bao giờ làm hỏng hệ thống khi sử dụng phương pháp này.

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

Tôi đã đi qua Internet để tìm một cái gì đó giống như nó và tìm thấy kịch bản búa cpu rất tiện dụng này.

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

Sử dụng các ví dụ được đề cập ở đây, nhưng cũng có sự giúp đỡ từ IRC, tôi đã phát triển kịch bản kiểm tra căng thẳng CPU của riêng mình. Nó sử dụng một subshell cho mỗi luồng và kỹ thuật vòng lặp vô tận. Bạn cũng có thể chỉ định số lượng chủ đề và lượng thời gian tương tác.

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

Sử dụng các ý tưởng ở đây, tạo mã tự động thoát sau một khoảng thời gian đã đặt, không phải giết các quy trình -

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

Đây là một mẹo cho tôi:

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

và nó không sử dụng gì ngoài bash.

Để tăng cường câu trả lời của dimba và cung cấp một cái gì đó dễ cắm hơn (vì tôi cần một cái gì đó tương tự). Tôi đã viết như sau bằng cách sử dụng khái niệm tải lên dd: D

Nó sẽ kiểm tra các lõi hiện tại và tạo ra nhiều luồng dd. Bắt đầu và kết thúc tải lõi với 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

Tôi đã kết hợp một số câu trả lời và thêm một cách để chia tỷ lệ căng thẳng cho tất cả các cpus có sẵn:

#!/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/nullchắc chắn là chính xác, nhưng cũng đáng nói đến là xác minh tối đa hóa việc sử dụng CPU đến 100%. Bạn có thể làm điều này với

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

Điều này yêu cầu đầu ra ps trung bình 1 phút của việc sử dụng cpu theo từng quy trình, sau đó tính tổng chúng với awk. Mặc dù ở mức trung bình 1 phút, ps đủ thông minh để biết liệu một quy trình chỉ diễn ra trong vài giây và điều chỉnh cửa sổ thời gian phù hợp. Do đó bạn có thể sử dụng lệnh này để xem ngay kết quả.

để tăng tải hoặc tiêu thụ CPU 100%

sha1sum /dev/zero &

sau đó bạn có thể thấy CPU sử dụng bằng cách gõ lệnh

top

để giải phóng tải

killall sha1sum

Chỉ cần dán bad boy này vào SSH hoặc bảng điều khiển của bất kỳ máy chủ nào chạy linux. Bạn có thể giết các tiến trình theo cách thủ công, nhưng tôi chỉ tắt máy chủ khi tôi hoàn thành, nhanh hơn.

Chỉnh sửa: Tôi đã cập nhật tập lệnh này để có tính năng hẹn giờ để không cần phải hủy các quy trình.

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