Bagaimana saya bisa menghasilkan beban CPU yang tinggi di server Linux?

Saat ini saya sedang dalam proses debug instalasi Cacti dan ingin membuat beban CPU untuk debug grafik penggunaan CPU saya.

Saya mencoba menjalankannya cat /dev/zero > /dev/null, yang berfungsi dengan baik tetapi hanya menggunakan 1 inti:

Apakah ada metode yang lebih baik untuk menguji / memaksimalkan sumber daya sistem yang sedang dimuat?

Terkait: Bagaimana saya bisa menghasilkan beban CPU yang tinggi pada Windows?

Coba stress Ini hampir setara dengan Windows consume.exe:

oliver$ ./stress --cpu 3
stress: info: [18472] dispatching hogs: 3 cpu, 0 io, 0 vm, 0 hdd

Tidak perlu menginstal paket tambahan, shell lama Anda yang baik dapat melakukannya sendiri.

One-liner ini akan memuat empat core ^{1 Anda} pada 100%:

for i in 1 2 3 4; do while : ; do : ; done & done

Cara kerjanya cukup sederhana, dimulai empat loop tanpa akhir. Masing-masing dari mereka mengulang instruksi nol ( :). Setiap loop dapat memuat inti CPU pada 100%.

Jika Anda menggunakan bash, ksh93dan rentang pendukung shell lainnya (yaitu tidak dashatau lebih lama ksh), Anda dapat menggunakan sintaksis non-portabel ini:

for i in {1..4}; do ...

Ganti 4dengan jumlah CPU yang ingin Anda muat jika berbeda 4.

Dengan asumsi Anda tidak memiliki pekerjaan latar belakang yang sudah berjalan ketika Anda meluncurkan salah satu dari loop ini, Anda dapat menghentikan pembuatan load dengan perintah itu:

for i in 1 2 3 4; do kill %$i; done

Menjawab komentar @ underscore_d, berikut adalah versi yang disempurnakan yang menyederhanakan banyak penghentian beban dan yang juga memungkinkan menentukan batas waktu (default 60 detik.) A Control- Cakan membunuh semua loop pelarian juga. Fungsi shell ini bekerja setidaknya di bawah bashdan ksh.

# Usage: lc [number_of_cpus_to_load [number_of_seconds] ]
lc() {
  (
    pids=""
    cpus=${1:-1}
    seconds=${2:-60}
    echo loading $cpus CPUs for $seconds seconds
    trap 'for p in $pids; do kill $p; done' 0
    for ((i=0;i<cpus;i++)); do while : ; do : ; done & pids="$pids $!"; done
    sleep $seconds
  )
}

¹ _{Perhatikan bahwa dengan CPU yang mendukung lebih dari satu thread per core (Hyper-threading), OS akan mengirimkan beban ke semua CPU virtual. Dalam hal itu, perilaku beban tergantung pada implementasi (setiap utas mungkin dilaporkan 100% sibuk atau tidak).} .

Saya membuat skrip python sederhana yang melakukan hal yang sama. Anda dapat mengontrol jumlah inti cpu yang ingin Anda muat. Hal yang baik tentang ini adalah ia tidak akan mengkonsumsi sumber daya lain selain cpu. (Saya pikir ide mark johnson akan menghabiskan banyak sumber daya I / O, yang tidak diinginkan di sini.)

from multiprocessing import Pool

def f(x):
    # Put any cpu (only) consuming operation here. I have given 1 below -
    while True:
        x * x

# decide how many cpus you need to load with.
no_of_cpu_to_be_consumed = 3

p = Pool(processes=no_of_cpu_to_be_consumed)
p.map(f, range(no_of_cpu_to_be_consumed))

Jalankan skrip ini dari terminal $ python temp1.py. Anda harus membunuh skrip saat selesai.

Di sini, adalah output konsumsi cpu saya ketika saya memuat 3 core saya.

Salah satu cara alternatif adalah

openssl speed -multi $(grep -ci processor /proc/cpuinfo)

atau (jika nproc ada)

openssl speed -multi $(nproc --all)

OpenSSL hampir selalu hadir di distro saat ini, jadi tidak perlu paket tambahan.

Mulai dua

sha1sum /dev/zero &

perintah untuk setiap inti di sistem Anda.

Untuk berhenti

killall sha1sum

atau

kill sha1sum

Saya biasanya mengambil suite cpuburn:

sudo apt-get install cpuburn
for i in {1..4}; do burnK7 & done

Ganti 4 dengan jumlah inti / HT-utas yang Anda miliki atau ingin Anda tekankan.

Catatan: Ini menekankan area chip sebanyak mungkin pada saat yang sama, ini diprogram untuk menghasilkan disipasi daya maksimum. Saya harus menulis posting ini untuk yang kedua kalinya, entah bagaimana mesin saya tidak menyukainya :-(

Anda juga bisa melakukan cpuburn secara berurutan:

burnP6 & burnP6 & burnP6 & burnP6 & 
[1] 28520
[2] 28521
[3] 28522
[4] 28523

Dan ketika Anda ingin menghentikan mereka:

killall burnP6

Anda juga bisa menggandakan burnP6 &agar sesuai dengan jumlah inti CPU di sistem Anda.

Saya telah mengembangkan stress-ng, alat stress terbaru yang dapat menekankan berbagai aspek dari sistem Linux. Untuk informasi lebih lanjut, lihat http://kernel.ubuntu.com/~cking/stress-ng/

Penggunaannya mirip dengan stres

$ stress-ng --cpu 4 --vm 2 --fork 8 --switch 4 --timeout 1m
stress-ng: info:  [32254] dispatching hogs: 4 cpu, 8 fork, 4 switch, 2 vm
stress-ng: info:  [32254] cache allocate: default cache size: 8192K

Instal dengan

sudo apt-get install stress-ng

Anda dapat menjalankan perintah itu sebanyak yang Anda inginkan, dan itu akan mengambil inti yang berbeda setiap kali:

$ CORES=1
$ for i in `seq 1 $CORES`; do cat /dev/zero > /dev/null &
> done
[1] 8388

https://github.com/GaetanoCarlucci/CPULoadGenerator

solusi yang cukup sederhana dan ilmiah.

Di sini Anda dapat melihat contoh dinamika di mana 50% beban dihasilkan pada inti CPU 0:

Anda dapat menjalankan proses pada core lain secara bersamaan.

Saya menggabungkan + jlliagre dan + ecabuk.

#!/bin/bash
lc() {
    nowMs=$(date +%s)
    (
        pids=""
        cpus=${1:-1}
        seconds=${2:-60}
        echo "[$(date)] loading $cpus CPUs for $seconds seconds"
        echo "[$(date)] Expected completion: [$(date --date=@$(expr $nowMs + $seconds))]"
        trap 'for p in $pids; do kill $p; done' 0
        for ((i=0;i<cpus;i++)); do
            sha1sum /dev/zero &
            pids="$pids $!";
        done
        sleep $seconds
    )
    echo "[$(date)] Done"
}

lc $@

Anda dapat gunakan:

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

Ulangi dd if=/dev/zero of=/dev/nulluntuk core CPU Anda.

Tekan tombol apa saja untuk menghentikan tes.

pxzadalah implementasi paralel dari xz.

pxz -9e /dev/zero --stdout >/dev/null harus melakukan trik, karena ini cukup cpu intensif.

Jika /dev/zerotidak cukup cepat (Anda perhatikan bahwa pxzI / O tercekik) dapat Anda lakukan pxz -9e /dev/zero --stdout | pxz -9e --stdout >/dev/null

Versi yang lebih baru xzmemiliki --threadsopsi yang merupakan pengganti pxz.

Inilah cara saya menggunakan dan tidak perlu menginstal apa pun tambahan.

Misalnya untuk memulai dengan 4 proses,

nproc | xargs seq | xargs -n1 -P4 md5sum /dev/zero

Anda dapat mengubah jumlah proses dengan opsi "-P" di atas.

Baris perintah sederhana juga melakukannya:

x="x" ; while : ; do x=$x$x ; echo -n "." ; done

Saya ingin menambahkan ini ke komentar @ jlliagre, tetapi saya tidak memiliki reputasi yang cukup. Jika Anda akan menggunakan kode ini di beberapa server dan jumlah CPU akan bervariasi, Anda dapat menggunakan perintah berikut:

for ((i=1; i<=`nproc --all`; i++)); do while : ; do : ; done & done

Ini akan memanfaatkan semua core di server Anda terlepas dari berapa banyak yang Anda miliki. Perintah nprocini adalah bagian dari coreutils sehingga harus di sebagian besar instalasi Linux.