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

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

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

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

Этот один лайнер будет загружать ваши четыре ядра1 на 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

• *

Answering @underscore_d’s comment, вот улучшенная версия, которая значительно упрощает остановку загрузки, а также позволяет указать тайм-аут (по умолчанию 60 секунд.) Контроллер 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
  )
}

1Note, что при поддержке процессорами более одного потока на ядро (Hyper-threading) операционная система будет посылать нагрузку всем виртуальным процессорам. В этом случае поведение нагрузки зависит от реализации (каждый поток может быть заявлен как занятый на 100% или нет).

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

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

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

Использование аналогично stress

$ 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

Обычно я беру кпуберн:

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

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

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

Вы также можете делать кпубурны в последовательностях:

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

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

killall burnP6

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

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

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

https://github.com/GaetanoCarlucci/CPULoadGenerator

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

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

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

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

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

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

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

Я объединил оба +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 для ваших ядер процессора.

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

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

Например, чтобы начать с 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.