Как я могу произвести высокую загрузку процессора на сервере Linux?

В настоящее время я нахожусь в процессе отладки установки Cacti и хочу создать загрузку ЦП для отладки графиков загрузки ЦП.

Я попытался просто запустить cat /dev/zero > /dev/null, который прекрасно работает, но использует только 1 ядро:

Есть ли лучший метод тестирования / максимизации системных ресурсов под нагрузкой?

Связанный: Как я могу произвести высокую загрузку ЦП на Windows?

Попробуйте stress Это в значительной степени эквивалент Windows consume.exe:

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

Нет необходимости устанавливать какой-либо дополнительный пакет, ваш старый добрый шелл может сделать это самостоятельно.

Этот однострочный загрузит ваши четыре ядра ¹ на 100%:

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

Как это работает, довольно просто, он запускает четыре бесконечных цикла. Каждый из них повторяет нулевую инструкцию ( :). Каждый цикл способен загружать ядро ​​процессора на 100%.

Если вы используете bash, ksh93и другие оболочки поддерживаете диапазоны, (т.е. не dashстарше ksh), вы можете использовать это не портативный синтаксис:

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

Замените 4на количество процессоров, которые вы хотите загрузить, если отличается от 4.

Предполагая, что при запуске одного из этих циклов у вас уже не было фоновой работы, вы можете остановить генерацию нагрузки с помощью этой команды:

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

Отвечая на комментарий @ underscore_d, вот улучшенная версия, которая значительно упрощает остановку загрузки, а также позволяет указать тайм-аут (по умолчанию 60 секунд.) A Control- Cтакже уничтожит все циклы разгона. Эта функция оболочки работает как минимум под bashи 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
  )
}

¹ _{Обратите внимание, что с процессорами, поддерживающими более одного потока на ядро ​​(Hyper-threading), ОС распределяет нагрузку на все виртуальные процессоры. В этом случае поведение загрузки зависит от реализации (для каждого потока может быть указано, что он занят на 100% или нет).} ,

Я сделал простой скрипт на Python, который делает то же самое. Вы можете контролировать количество ядер процессора, которые вы хотите загрузить. Хорошая вещь об этом - то, что это не будет потреблять никакой другой ресурс кроме процессора. (Я думаю, что идея Марка Джонсона потребует много ресурсов ввода-вывода, что здесь нежелательно.)

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

Просто запустите этот скрипт из терминала $ python temp1.py. Вам нужно убить сценарий, когда вы закончите.

Вот мой вывод потребления ЦП при загрузке 3 моих ядер.

Одним из альтернативных способов будет

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

или (если присутствует nproc)

openssl speed -multi $(nproc --all)

OpenSSL почти всегда присутствует в современных дистрибутивах, поэтому никаких дополнительных пакетов не требуется.

Начать два

sha1sum /dev/zero &

Команды для каждого ядра в вашей системе.

Прекратить

killall sha1sum

или же

kill sha1sum

Я обычно беру cpuburn suite:

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

Замените 4 числом ядер / HT-потоков, которые у вас есть или которые вы хотите подчеркнуть.

Примечание. Это подчеркивает как можно большую площадь микросхемы, так как она запрограммирована на максимальное рассеивание мощности. Я должен был написать этот пост во второй раз, как-то моя машина не понравилась :-(

Вы также можете сделать cpuburn в последовательности:

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

И когда вы хотите остановить их

killall burnP6

Вы также можете умножить, burnP6 &чтобы соответствовать количеству процессорных ядер в вашей системе.

Я разрабатывал стресс-нг, обновленный инструмент стресса, который может подчеркнуть широкий спектр аспектов системы Linux. Для получения дополнительной информации см. Http://kernel.ubuntu.com/~cking/stress-ng/.

Использование похоже на стресс

$ 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

Установить с

sudo apt-get install stress-ng

Вы можете выполнить эту команду столько раз, сколько захотите, и каждый раз она будет занимать другое ядро:

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

https://github.com/GaetanoCarlucci/CPULoadGenerator

довольно простое и научное решение.

Здесь вы можете увидеть пример динамики, в которой 50% нагрузки генерируется на ядре 0 процессора:

Вы можете запустить процесс на других ядрах одновременно.

Я объединил оба + jlliagre и + 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 $@

Вы можете использовать:

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

Повторите dd if=/dev/zero of=/dev/nullдля ваших процессорных ядер.

Нажмите любую клавишу, чтобы остановить тест.

pxzэто параллельная реализация xz.

pxz -9e /dev/zero --stdout >/dev/null следует сделать свое дело, так как это довольно интенсивный процесс.

Если /dev/zeroэто не достаточно быстро (вы заметили, что pxzввод / вывод ограничен), вы можете сделать pxz -9e /dev/zero --stdout | pxz -9e --stdout >/dev/null

Более новые версии xzимеют --threadsопцию, которая является заменой pxz.

Вот способ, которым я пользуюсь, и нет необходимости устанавливать что-либо дополнительное.

Например, чтобы начать с 4 процессов,

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

Вы можете изменить количество процессов с помощью опции «-P» выше.

Простая командная строка делает это тоже:

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

Я хотел добавить это к комментарию @ jlliagre, но мне не хватает репутации. Если вы собираетесь использовать этот код на нескольких серверах и количество процессоров будет различаться, вы можете использовать следующую команду:

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

Это будет использовать все ядра на вашем сервере, независимо от того, сколько у вас есть. Команда nprocявляется частью coreutils, поэтому должна быть в большинстве установок Linux.