stress-ng - Online na nuvem

PROGRAMA:

NOME

stress-ng - uma ferramenta para carregar e sobrecarregar um sistema de computador

SINOPSE

estresse [OPÇÃO [ARG]] ...

DESCRIÇÃO

stress-ng testará o estresse de um sistema de computador de várias maneiras selecionáveis. Foi desenhado
para exercitar vários subsistemas físicos de um computador, bem como os vários sistemas operacionais
interfaces do kernel do sistema. stress-ng também tem uma ampla gama de testes de estresse específicos de CPU
que exercita ponto flutuante, inteiro, manipulação de bits e fluxo de controle.

stress-ng foi originalmente planejado para fazer uma máquina trabalhar muito e desarmar problemas de hardware
tais como sobrecargas térmicas, bem como bugs do sistema operacional que só ocorrem quando um sistema está
sendo espancado com força. Use o estresse com cuidado, pois alguns dos testes podem fazer um sistema funcionar
quente em hardware mal projetado e também pode causar sobrecarga excessiva do sistema, que pode ser
difícil de parar.

stress-ng também pode medir taxas de transferência de teste; isso pode ser útil para observar
alterações de desempenho em diferentes versões de sistema operacional ou tipos de hardware.
No entanto, ele nunca foi pretendido para ser usado como um conjunto de teste de benchmark preciso, então faça
NÃO use desta maneira.

Executar stress-ng com privilégios de root irá ajustar as configurações de memória em sistemas Linux
para tornar os estressores impossíveis de matar em situações de pouca memória, então use isso com cautela. Com
o privilégio apropriado, o stress-ng pode permitir que a classe de ionício e os níveis de ionício sejam
ajustado, novamente, deve ser usado com cuidado.

Pode-se especificar o número de processos a invocar por tipo de teste de estresse; especificando um
valor negativo ou zero irá selecionar o número de processadores disponíveis conforme definido por
sysconf (_SC_NPROCESSORS_CONF).

OPÇÕES

Geral estresse ao controle opções:

--agressivo
permite mais opções agressivas de arquivo, cache e memória. Isso pode desacelerar os testes,
aumentar as latências e reduzir o número de operações bogo, bem como alterar o
equilíbrio entre o tempo do usuário e o tempo do sistema usado, dependendo do tipo de estressor que está sendo
usava.

-a N, --tudo N
iniciar N instâncias de cada estressor. Se N for menor que zero, então o número de CPUs
online é usado para o número de instâncias. Se N for zero, então o número de CPUs
no sistema é usado.

-b N, --saia de perto N
aguarde N microssegundos entre o início de cada processo do trabalhador de estresse. Isso permite
um para aumentar os testes de estresse ao longo do tempo.

--classe nome
especifique a classe de estressores a serem executados. Os estressores são classificados em um ou mais dos
as seguintes classes: cpu, cpu-cache, dispositivo, io, interrupção, sistema de arquivos, memória,
rede, sistema operacional, pipe, planejador e vm. Alguns estressores se enquadram em apenas uma classe. Para
Por exemplo, o estressor 'get' está apenas na classe 'os'. Outros estressores caem em
mais de uma classe, por exemplo, o estressor 'lsearch' cai na 'cpu',
classes 'cpu-cache' e 'memory', pois exercita todas essas três. Selecionando um
classe específica irá executar todos os estressores que se enquadram nessa classe apenas quando executado
com a opção --sequential.

-n, --funcionamento a seco
analise opções, mas não execute testes de estresse. Um ambiente autônomo.

-h, --Socorro
mostre ajuda.

--ignite-cpu
altere os controles do kernel para tentar maximizar a CPU. Isso requer privilégio de root para
alterar vários / sys controles de interface. Atualmente, isso só funciona para Intel P-State
sistemas x86 habilitados no Linux.

- classe de ionice classe
especifique a classe ionice (somente no Linux). Pode ser inativo (padrão), besteffort, be,
tempo real, rt.

- nível de ionício nível
especifique o nível de ionice (somente no Linux). Para inativo, 0 é a única opção possível. Para
besteffort ou valores em tempo real 0 (prioridade mais alta) a 7 (prioridade mais baixa). Ver
ionizar(1) para obter mais detalhes.

-k, --keep-nome
por padrão, stress-ng tentará mudar o nome dos processos de estresse
de acordo com sua funcionalidade; esta opção desativa isso e mantém o processo
names para ser o nome do processo pai, ou seja, stress-ng.

--log-breve
por padrão, o stress-ng relatará o nome do programa, o tipo de mensagem e o
id do processo como um prefixo para todas as saídas. A opção --log-brief irá mostrar mensagens
sem esses campos para produzir uma saída menos detalhada.

--arquivo de log nome do arquivo
grava mensagens no arquivo de log especificado.

--maximizar
substitui as configurações padrão do estressor e, em vez disso, as define para o máximo
configurações permitidas. Esses padrões sempre podem ser substituídos pelo estressor por
opções de configuração, se necessário.

--Métricas
número de saída de operações bogo no total realizadas pelos processos de estresse. Observação
que essas não são uma métrica confiável de desempenho ou rendimento e não foram
projetado para ser usado em qualquer tipo de benchmarking. As métricas são apenas uma forma útil
para observar como um sistema se comporta quando está sob vários tipos de carga.

As seguintes colunas de informações são geradas:

Coluna Título Explicação
bogo ops número de iterações do estressor durante a execução.
Esta é a métrica de quanto "trabalho" geral tem sido
alcançado nas operações de bogo.
duração média do relógio de parede em tempo real (segundos) (em segundos) do
estressor. Este é o tempo total do relógio de parede de todos os
instâncias desse estressor particular dividido pelo
número desses estressores sendo executados.
tempo usr (segundos) tempo total do usuário (em segundos) consumido executando todos os
instâncias do estressor.
sys time (segundos) tempo total do sistema (em segundos) consumido executando todos os
instâncias do estressor.
bogo ops / s (tempo real) total de operações bogo por segundo com base na execução do relógio de parede
Tempo. O tempo do relógio de parede reflete a corrida aparente
Tempo. Quanto mais processadores se tem em um sistema, mais
a carga de trabalho pode ser distribuída para estes e, portanto,
o tempo do relógio de parede irá reduzir e a taxa de operações do bogo
vai aumentar. Este é essencialmente o bogo "aparente"
taxa de operações do sistema.

Operações bogo / s (tempo usr + sys) total de operações bogo por segundo com base no cumulativo
hora do usuário e do sistema. Esta é a taxa real de operações de bogo de
o sistema levando em consideração o tempo real
tempo de execução do estressor em todas as
processadores. Geralmente, isso diminuirá à medida que se adiciona
mais estressores simultâneos devido à contenção no cache,
memória, unidades de execução, barramentos e dispositivos de I / O.

--metrics-bref
habilite métricas e apenas métricas de saída que não sejam zero.

--minimizar
substitui as configurações padrão do estressor e, em vez disso, as define para o mínimo
configurações permitidas. Esses padrões sempre podem ser substituídos pelo estressor por
opções de configuração, se necessário.

--não aconselhar
da versão 0.02.26 stress-ng chama automaticamente louco(2) com conselho aleatório
opções antes de cada mmap e munmap para enfatizar o subsistema vm um pouco mais.
A opção --no-advise desativa esse padrão.

--page-in
toque nas páginas alocadas que não estão no núcleo, forçando-as a serem paginadas de volta.
é uma opção útil para forçar todas as páginas alocadas a serem paginadas ao usar o
estressores bigheap, mmap e vm. Isso prejudicará gravemente o desempenho quando o
a memória no sistema é menor do que os tamanhos de buffer alocados. Este usa mincore(2)
para determinar as páginas que não estão no núcleo e, portanto, precisam ser tocadas para paginá-las
de volta.

--patológico
habilitar estressores que são conhecidos por travar os sistemas. Alguns estressores podem rapidamente
consumir recursos de tal forma que eles podem rapidamente travar um sistema antes do
kernel pode OOM matá-los. Esses estressores não são habilitados por padrão, esta opção
os habilita, mas provavelmente você não deseja fazer isso. Você foi avisado.

--perf medir a atividade do processador e do sistema usando eventos de desempenho. Linux apenas e ressalva
emptor, de acordo com perf_event_open(2): "Sempre verifique seus resultados! Vários
eventos generalizados tiveram valores errados. "

-q, --quieto
não mostra nenhuma saída.

-r N, --aleatória N
iniciar N trabalhadores de estresse aleatórios. Se N for 0, então o número de processadores configurados
é usado para N.

--sched agendador
selecione o planejador nomeado (apenas no Linux). Para ver a lista de agendadores disponíveis
use: stress-ng --sched que

--sched-prio prio
selecione o nível de prioridade do planejador (apenas no Linux). Se o planejador não
suporte isso, então o nível de prioridade padrão de 0 é escolhido.

--sequencial N
execute sequencialmente todos os estressores, um por um, por um padrão de 60 segundos. o
número de instâncias de cada estressor individual a ser iniciado é N. Se N for menor
do que zero, então o número de CPUs online é usado para o número de instâncias. Se
N é zero, então o número de CPUs no sistema é usado. Use a opção --timeout
para especificar a duração de execução de cada estressor.

--syslog
saída de log (exceto para mensagens -v detalhadas) para o syslog.

--caminho temporário caminho
especificar um caminho para diretórios temporários stress-ng e arquivos temporários; o padrão
path é o diretório de trabalho atual. Este caminho deve ter acesso de leitura e gravação
para os processos de estresse de estresse-ng.

-t N, --tempo esgotado N
pare o teste de estresse após N segundos. Também se pode especificar as unidades de tempo em
segundos, minutos, horas, dias ou anos com o sufixo s, m, h, d ou y.

--timer-folga N
ajuste a folga do cronômetro por processo para N nanossegundos (somente Linux). Aumentando o
a folga do cronômetro permite que o kernel aglutine os eventos do cronômetro adicionando algumas imprecisões ao
tempos de expiração do temporizador e, portanto, reduza os wakeups. Por outro lado, diminuindo o cronômetro
a folga aumentará os wakeups. Um valor de 0 para a folga do cronômetro definirá o sistema
padrão de 50,000 nanossegundos.

- vezes
mostrar os tempos cumulativos do usuário e do sistema de todos os processos filho no final de
a corrida do estresse. A porcentagem de utilização do tempo de CPU disponível também é
calculado a partir do número de CPUs on-line no sistema.

--tz colete as temperaturas das zonas térmicas disponíveis na máquina (somente Linux).
Alguns dispositivos podem ter uma ou mais zonas térmicas, enquanto outros podem não ter nenhuma.

-dentro, --verbose
mostra todas as saídas de depuração, avisos e informações normais.

--verificar
verifique os resultados quando um teste é executado. Isso não está disponível em todos os testes. Isso vai
verificar a integridade dos cálculos ou do conteúdo da memória de uma execução de teste e relatar para
stderr quaisquer falhas inesperadas.

-V, --versão
mostrar a versão.

-x, --excluir Lista
especifique uma lista de um ou mais estressores a serem excluídos (ou seja, não os execute).
Isso é útil para excluir estressores específicos quando se seleciona muitos estressores para executar
usando as opções --class, --sequential, --all e --random. Exemplo, corra
os estressores da classe cpu simultaneamente e excluem os numa e os estressores de pesquisa:

stress-ng --class cpu --todos 1 -x numa, bsearch, hsearch, lsearch

-Sim, --yaml nome do arquivo
a saída reuniu estatísticas para um arquivo formatado em YAML denominado 'nome do arquivo'.

Estressor específico opções:

--afinidade N
iniciar N workers que mudam rapidamente a afinidade da CPU (somente no Linux). Mudando rapidamente
A afinidade da CPU pode contribuir para o mau comportamento do cache.

--afinidade-ops N
pare os workers de afinidade após as operações de afinidade do N bogo (somente no Linux).

--afinidade-rand
alterne a afinidade da CPU aleatoriamente, em vez do padrão sequencialmente.

--af-alg N
iniciar N workers que exercem o domínio de soquete AF_ALG fazendo hash de vários tamanhos
mensagens aleatórias usando SHA1, SHA224, SHA256, SHA384, SHA512, MD4, MD5, RMD128,
RMD160, RMD256, RMD320, WP256, WP384, WP512, TGR128, TGR160 e hashes TGR192.
(Somente Linux).

--af-alg-ops N
pare os workers af-alg após N mensagens AF_ALG serem hash.

--ai N
iniciar N workers que emitem várias pequenas gravações e leituras assíncronas de I / O em um
arquivo temporário relativamente pequeno usando a interface POSIX aio. Isso só vai bater
o cache do sistema de arquivos e consome muito tempo do usuário e do kernel na emissão e
manipulação de solicitações de E / S. Por padrão, cada processo de trabalho irá lidar com 16 concorrentes
Solicitações de E / S.

--aio-ops N
pare os workers de E / S assíncronos POSIX após solicitações de E / S assíncronas N bogo.

--aio-solicitações N
especificar o número de solicitações de E / S assíncronas POSIX que cada trabalhador deve emitir, o
o padrão é 16; 1 a 4096 são permitidos.

--aiol N
iniciar N workers que emitem várias gravações de E / S assíncronas aleatórias de 4 K usando o
Chamadas de sistema Linux aio io_setup(2) io_submit(2) io_getevents(2) e
io_destroy(2) Por padrão, cada processo de trabalho lidará com 16 E / S simultâneas
pedidos.

--aiol-ops N
pare os workers de E / S assíncronos do Linux após solicitações de E / S assíncronas N bogo.

--aiol-solicitações N
especificar o número de solicitações de I / O assíncronas do Linux que cada trabalhador deve emitir, o
o padrão é 16; 1 a 4096 são permitidos.

--apparmor N
inicie N workers que exercem várias partes da interface do AppArmor. Atualmente
é necessário ter permissão de root para executar este teste específico. Este teste está disponível apenas
em sistemas Linux com suporte do AppArmor.

--apparmor-ops
interromper os trabalhadores do AppArmor após as operações do N bogo.

-B N, --grande N
iniciar N workers que aumentam seus heaps realocando a memória. Se a memória insuficiente
killer (OOM) no Linux mata o trabalhador ou a alocação falha, em seguida, a alocação
o processo começa tudo de novo. Observe que o ajuste OOM para o trabalhador está definido
para que o assassino OOM trate esses trabalhadores como os primeiros processos candidatos a
matar.

--bigheap-ops N
pare os big heap workers após a conclusão das operações de alocação de N bogo.

--grande crescimento N
especifique a quantidade de memória para aumentar o heap por iteração. O tamanho pode ser de 4K a
64 MB. O padrão é 64K.

--bind-montar N
iniciar N workers que repetidamente vinculam mount / a / dentro de um namespace do usuário. Isso pode
consome recursos rapidamente, forçando situações de falta de memória. Não use isto
estressor, a menos que você queira correr o risco de pendurar sua máquina.

--bind-mount-ops N
parar após N bind montar operações bogo.

--brk N
iniciar N workers que aumentam o segmento de dados em uma página por vez usando vários
brk(2) chamadas. Cada nova página alocada com sucesso é tocada para garantir que seja
residente na memória. Se ocorrer uma condição de falta de memória, o teste será reiniciado
o segmento de dados até o ponto anterior ao início e repita o segmento de dados
redimensionar novamente. O processo ajusta a configuração de falta de memória para que possa
ser eliminado pelo assassino sem memória (OOM) antes de outros processos. Se for
morto pelo assassino OOM, então ele será reiniciado automaticamente por um monitoramento
processo pai.

--brk-ops N
pare os trabalhadores brk após as operações em N bogo brk.

--brk-notouch
não toque em cada página de segmento de dados recém-alocada. Isso desativa o padrão de
tocar em cada página recém-alocada e, portanto, evita que o kernel necessariamente
apoiando a página com memória física real.

--bsearch N
iniciar N workers que procuram binários uma matriz classificada de inteiros de 32 bits usando
pesquisa(3). Por padrão, existem 65536 elementos na matriz. Este é um útil
método para exercitar o acesso aleatório à memória e ao cache do processador.

--bsearch-ops N
pare o trabalhador bsearch depois que as operações do N bogo bsearch forem concluídas.

--bsearch-size N
especifique o tamanho (número de inteiros de 32 bits) na matriz para bsearch. O tamanho pode ser
de 1K a 4M.

-C N, --cache N
iniciar N workers que executam leituras e gravações de memória espalhadas aleatoriamente no thrash
o cache da CPU. O código não determina de forma inteligente o cache da CPU
configuração e por isso pode ser abaixo do ideal na produção de leitura / gravação acertada
atividade para alguns processadores.

--cache-fence
forçar a serialização de gravação em cada operação de armazenamento (x86 apenas). Este é um ambiente autônomo para
arquiteturas não x86.

--cache-flush
forçar a liberação do cache em cada operação de armazenamento (somente x86). Este é um ambiente autônomo para não-x86
arquiteturas.

--nível de cache N
especificar o nível de cache para o exercício (1 = cache L1, 2 = cache L2, 3 = cache L3 / LLC (o
predefinição)). Se a hierarquia do cache não puder ser determinada, os padrões integrados
Aplique.

--cache-sem afinidade
não mude a afinidade do processador quando --cache está em vigor.

--cache-ops N
pare os trabalhadores do cache thrash após as operações do N bogo cache thrash.

--cache-pré-busca
forçar pré-busca de leitura no próximo endereço de leitura em arquiteturas que suportam pré-busca.

--cache-way N
especifique o número de maneiras de fazer exercícios em cache. Isso permite um subconjunto do geral
tamanho do cache a ser exercido.

--boné N
iniciar N workers que leem as capacidades por processo por meio de chamadas para capit(2) (Linux
só).

--cap-ops N
parar após N cap bogo operações.

--chdir N
iniciar N workers que mudam de diretório entre 8192 diretórios usando chdir(2).

--chdir-ops N
parar após as operações N chdir bogo.

--chmod N
iniciar N workers que alteram os bits do modo de arquivo por meio de chmod(2) e fchmod(2) no
mesmo arquivo. Quanto maior for o valor de N, maior será a contenção no arquivo único.
O estressor funcionará por meio de todas as combinações de bits de modo.

--chmod-ops N
parar após as operações N chmod bogo.

--relógio N
iniciar N trabalhadores exercitando relógios e temporizadores POSIX. Para todos os tipos de relógio conhecidos, este
vai exercitar relógio_getres(2) relógio_gettime(2) e clock_nanosleep(2) Para todos
cronômetros conhecidos, ele criará um cronômetro de 50000 ns e o pesquisará até que expire.
Este estressor causará frequentes mudanças de contexto.

--clock-ops N
pare os trabalhadores de estresse do relógio após as operações do N bogo.

--clone N
iniciar N workers que criam clones (por meio do clonar(2) chamada de sistema). Isso vai
tente criar rapidamente um padrão de 8192 clones que morrem imediatamente e esperam em um
estado de zumbi até que sejam colhidos. Assim que o número máximo de clones for alcançado
(ou o clone falha porque um atingiu o máximo permitido) o clone mais antigo
thread é colhido e um novo clone é então criado da maneira first-in first-out,
e depois repetido. Um sinalizador de clone aleatório é selecionado para cada clone para tentar
exercer diferentes operações de clones. O estressor de clone é uma opção única do Linux.

- ops de clone N
pare os trabalhadores de estresse do clone após as operações de clone do N bogo.

--clone-max N
tente criar até N threads clones. Isso pode não ser alcançado se o sistema
limite é menor que N.

--contexto N
iniciar N workers que executam três threads que usam contexto de troca(3) para implementar o
comutação de contexto thread a thread. Isso exerce economia de contexto de processo rápido e
restauração e largura de banda limitada por taxas de registro e gravação de memória e restauração.

--context-ops N
pare os trabalhadores de contexto N após as trocas de contexto N bogo. Neste estressor, 1 bogo op
é equivalente a 1000 chamadas de contexto de swap.

--copiar arquivo N
iniciar N estressores que copiam um arquivo usando o Linux copy_file_range(2) chamada de sistema.
Pedaços de 2 MB de dados são copiados de locais aleatórios de um arquivo para aleatório
locais para um arquivo de destino. Por padrão, os arquivos têm 256 MB de tamanho. Dados são
sincronizado com o sistema de arquivos após cada copy_file_range(2) ligue.

- ops de cópia de arquivo N
parar após N chamadas de copy_file_range ().

--copy-file-bytes N
tamanho do arquivo de cópia, o padrão é 256 MB. Pode-se especificar o tamanho em unidades de bytes,
KBytes, MBytes e GBytes usando o sufixo b, k, m ou g.

-c N, --CPU N
iniciar N trabalhadores exercitando a CPU trabalhando sequencialmente em todos os
diferentes métodos de estresse da CPU. Em vez de exercitar todos os métodos de estresse da CPU, um
pode especificar um método específico de estresse da CPU com a opção --cpu-method.

--cpu-ops N
pare os trabalhadores de estresse da CPU após as operações do N bogo.

-l P, --cpu-carregar P
carregue a CPU com P por cento de carregamento para os trabalhadores de estresse da CPU. 0 é efetivamente um
hibernar (sem carga) e 100 está carregando totalmente. O loop de carregamento é dividido em computação
tempo (carga%) e tempo de sono (100% - carga%). A precisão depende da carga geral de
o processador e a capacidade de resposta do programador, de modo que a carga real pode ser
diferente da carga desejada. Observe que o número de operações da CPU bogo pode
não ser escalonado linearmente com a carga, pois alguns sistemas empregam escalonamento de frequência de CPU
e assim, cargas mais pesadas produzem um aumento na frequência da CPU e maior capacidade de processamento da CPU
operações.

--cpu-load-slice S
note - esta opção só é útil quando --cpu-load é menor que 100%. A carga da CPU
é dividido em vários ciclos de ocupado e ocioso. Use esta opção para especificar o
duração de uma fração de tempo ocupada. Um valor negativo para S especifica o número de
iterações para rodar antes de deixar a CPU ociosa (por exemplo, -30 invoca 30 iterações de uma CPU
loop de estresse). Um valor zero seleciona um tempo ocupado aleatório entre 0 e 0.5 segundos.
Um valor positivo para S especifica o número de milissegundos a ser executado antes da marcha lenta
a CPU (por exemplo, 100 mantém a CPU ocupada por 0.1 segundos). Especificando pequenos valores para
S empresta para pequenos intervalos de tempo e agendamento mais suave. Configurando --cpu-load como um
valor relativamente baixo e --cpu-load-slice ser grande fará o ciclo da CPU entre
longos ciclos ociosos e ocupados e exercem diferentes frequências de CPU. A térmica
intervalo da CPU também é ciclado, então este é um bom mecanismo para exercitar o
agendador, escala de frequência e mecanismos de resfriamento térmico passivo / ativo.

--cpu-método método
especifique um método de estresse da CPU. Por padrão, todos os métodos de estresse são exercidos
sequencialmente, no entanto, pode-se especificar apenas um método a ser usado, se necessário.
Os métodos de estresse de CPU disponíveis são descritos a seguir:

Forma Descrição
tudo itera sobre todos os métodos de estresse de CPU abaixo
função ackermann Ackermann: calcule A (3, 10), onde:
A (m, n) = n + 1 se m = 0;
A (m - 1, 1) se m> 0 e n = 0;
A (m - 1, A (m, n - 1)) se m> 0 e n> 0
bitops várias operações de bit do bithack, a saber: bits reversos, paridade
verificar, contagem de bits, arredondar para a potência mais próxima de 2
callfunc chama recursivamente 8 função de argumento C para uma profundidade de 1024 chamadas
e relaxar
cfloat 1000 iterações de uma mistura de operações complexas de ponto flutuante
cdobro de 1000 iterações de uma mistura de complexo de ponto flutuante duplo
operações
clongdouble 1000 iterações de uma mistura de longo complexo de ponto flutuante duplo
operações
correlate execute uma correlação de 16384 × 1024 de duplas aleatórias
O crc16 calcula 1024 rodadas de CCITT CRC16 em dados aleatórios
decimal32 1000 iterações de uma mistura de ponto flutuante decimal de 32 bits
operações (apenas GCC)
decimal64 1000 iterações de uma mistura de ponto flutuante decimal de 64 bits
operações (apenas GCC)
decimal128 1000 iterações de uma mistura de ponto flutuante decimal de 128 bits
operações (apenas GCC)
dither Floyd-Steinberg dithering de uma imagem aleatória de 1024 × 768 de 8 bits
até 1 bit de profundidade.
djb2a 128 rodadas de hash DJB2a (Dan Bernstein hash usando o xor
variante) em 128 a 1 bytes de strings aleatórias
double 1000 iterations de uma mistura de ponto flutuante de dupla precisão
operações
Calcule euler usando n = (1 + (1 ÷ n)) ↑ n
explog iterate on n = exp (log (n) ÷ 1.00002)
fibonacci calcula a sequência de Fibonacci de 0, 1, 1, 2, 5, 8 ...
fft 4096 amostra Transformada Rápida de Fourier
float 1000 iterações de uma combinação de operações de ponto flutuante
fnv1a 128 rodadas de hash FNV-1a (Fowler – Noll – Vo hash usando o xor então
multiplicar variante) em 128 a 1 bytes de strings aleatórias
gama calcular a constante de Euler-Mascheroni γ usando o limite
diferença entre a série harmônica (1 + 1/2 + 1/3 + 1/4 + 1/5
... + 1 / n) e o logaritmo natural ln (n), para n = 80000.
gcd compute GCD de inteiros
cinza calcular binário para código cinza e código cinza de volta para binário para
inteiros de 0 a 65535
hamming compute códigos Hamming H (8,4) em 262144 lotes de dados de 4 bits. Esse
transforma dados de 4 bits em código de Hamming de 8 bits contendo 4 bits de paridade.
Para os bits de dados d1..d4, os bits de paridade são calculados como:
p1 = d2 + d3 + d4
p2 = d1 + d3 + d4
p3 = d1 + d2 + d4
p4 = d1 + d2 + d3
hanoi resolve uma pilha de 21 torres de disco de Hanói usando a solução recursiva
cálculo hiperbólico sinh (θ) × cosh (θ) + sinh (2θ) + cosh (3θ) para flutuante, duplo
e funções de seno e cosseno hiperbólico duplo longo, onde θ = 0
para 2π em 1500 passos
idct 8 × 8 IDCT (Transformada Inversa de Cosseno Discreta)
int8 1000 iterações de uma combinação de operações inteiras de 8 bits
int16 1000 iterações de uma combinação de operações inteiras de 16 bits
int32 1000 iterações de uma combinação de operações inteiras de 32 bits
int64 1000 iterações de uma combinação de operações inteiras de 64 bits

int128 1000 iterações de uma mistura de operações inteiras de 128 bits (apenas GCC)
int32float 1000 iterações de uma mistura de inteiros de 32 bits e ponto flutuante
operações
int32duplo 1000 iterações de uma mistura de inteiro de 32 bits e precisão dupla
operações de ponto flutuante
int32longdouble 1000 iterações de uma mistura de inteiro de 32 bits e duplo longo
operações de ponto flutuante de precisão
int64float 1000 iterações de uma mistura de inteiros de 64 bits e ponto flutuante
operações
int64duplo 1000 iterações de uma mistura de inteiro de 64 bits e precisão dupla
operações de ponto flutuante
int64longdouble 1000 iterações de uma mistura de inteiro de 64 bits e duplo longo
operações de ponto flutuante de precisão
int128float 1000 iterações de uma mistura de inteiros de 128 bits e ponto flutuante
operações (apenas GCC)
int128duplo 1000 iterações de uma mistura de inteiro de 128 bits e precisão dupla
operações de ponto flutuante (apenas GCC)
int128longdouble 1000 iterações de uma mistura de inteiro de 128 bits e duplo longo
operações de ponto flutuante de precisão (apenas GCC)
int128decimal32 1000 iterações de uma mistura de inteiro de 128 bits e decimal de 32 bits
operações de ponto flutuante (apenas GCC)
int128decimal64 1000 iterações de uma mistura de inteiro de 128 bits e decimal de 64 bits
operações de ponto flutuante (apenas GCC)
int128decimal128 1000 iterações de uma mistura de inteiro de 128 bits e decimal de 128 bits
operações de ponto flutuante (apenas GCC)
jenkin Jenkin's integer hash em 128 rodadas de 128..1 bytes de dados aleatórios
jmp Simples comparação não otimizada>, <, == e ramificação jmp
ln2 computar ln(2) com base na série:
1 - 1/2 + 1/3 - 1/4 + 1/5 - 1/6...
longdouble 1000 iterations de uma mistura de ponto flutuante de dupla precisão longa
operações
laço simples laço vazio
matrixprod produto da matriz de duas matrizes 128 × 128 de flutuadores duplos. Testando
em hardware x64 de 86 bits mostra que oferece uma boa combinação de
operações de memória, cache e ponto flutuante e é provavelmente o
melhor método de CPU a ser usado para esquentar a CPU.
nsqrt compute sqrt () de duplas longas usando Newton-Raphson
omega calcula a constante omega definida por Ωe ↑ Ω = 1 usando eficiente
iteração de Ωn + 1 = (1 + Ωn) / (1 + e ↑ Ωn)
paridade computacional paridade usando vários métodos do Bit Standford
Twiddling Hacks. Os métodos empregados são: o caminho ingênuo, o ingênuo
forma com a otimização de contagem de bits de Brian Kernigan, o
a maneira multiplicar, a maneira paralela e as formas da tabela de pesquisa (2
variações).
phi calcula a Razão Áurea ϕ usando séries
pi computar π usando o algoritmo de convergência rápida Srinivasa Ramanujan
pjw 128 rodadas de função hash pjw em 128 a 1 bytes de aleatório
cordas
prime encontre todos os primos no intervalo 1..1000000 usando um ligeiramente
pesquisa de divisão de teste ingênuo de força bruta otimizada
psi calcule ψ (a constante recíproca de Fibonacci) usando a soma do
recíprocos dos números de Fibonacci
rainhas computam todas as soluções do problema clássico das 8 rainhas para
tamanhos de placa 1..12
rand 16384 iterações de rand (), em que rand é o MWC pseudo aleatório
gerador de números. A função aleatória MWC concatena dois de 16 bits
geradores multiplique com transporte:
x (n) = 36969 × x (n - 1) + transporte,
y (n) = 18000 × y (n - 1) + mod de transporte 2 ↑ 16

e tem período de cerca de 2 ↑ 60
rand48 16384 iterações de drand48(3) e lrand48(3)
rgb converter RGB para YUV e de volta para RGB (CCIR 601)
sdbm 128 rodadas de hash sdbm (conforme usado no banco de dados SDBM e GNU awk)
em 128 a 1 bytes de strings aleatórias
peneira encontre os primos no intervalo 1..10000000 usando a peneira de
Eratóstenes
sqrt compute sqrt (rand ()), onde rand é o número pseudoaleatório MWC
gerador

trig compute sin (θ) × cos (θ) + sin (2θ) + cos (3θ) para float, double e
funções seno e cosseno duplas longas onde θ = 0 a 2π em 1500
passos
union executa aritmética de inteiros em uma combinação de campos de bits em uma união C.
Isso exercita o quão bem o compilador e a CPU podem executar inteiros
campo de bits carrega e armazena.
zeta calcula a função Riemann Zeta ζ (s) para s = 2.0..10.0

Observe que alguns desses métodos tentam exercitar a CPU com cálculos encontrados em
alguns casos de uso do mundo real. No entanto, o código não foi otimizado em uma
base da arquitetura, então pode ser um subótimo em comparação com o código otimizado à mão usado em
alguns aplicativos. Eles tentam representar as combinações de instruções típicas encontradas em
esses casos de uso.

--cpu-online N
iniciar N workers que colocam as CPUs selecionadas aleatoriamente offline e online. Este Linux apenas
estressor requer privilégio de root para executar esta ação.

--cpu-online-ops N
parar após as operações offline / online.

--cripta N
iniciar N workers que criptografam uma senha aleatória de 16 caracteres usando cripta(3) o
a senha é criptografada usando os métodos de criptografia MD5, SHA-256 e SHA-512.

--crypt-ops N
parar após as operações de criptografia do N bogo.

--daemon N
iniciar N workers, cada um criando um daemon que morre imediatamente após a criação
outro daemon e assim por diante. Isso funciona efetivamente por meio da tabela de processo com
processos de curta duração que não têm um pai e são esperados pelo init. Esse
pressiona o init para fazer a colheita infantil rápida. Os processos daemon realizam o
mistura usual de chamadas para se transformar em daemons UNIX típicos, então isso imita artificialmente
muito forte estresse do sistema daemon.

--daemon-ops N
pare os daemon workers depois que os N daemons forem criados.

-D N, --dentry N
inicie N workers que criam e removem entradas de diretório. Isso deve criar o arquivo
atividade de metadados do sistema. Os nomes de entrada de diretório são sufixados por um código cinza
número codificado para tentar misturar o hash do namespace.

--dentry-ops N
pare os trabalhadores do denty thrash após as operações do denty do N bogo.

- ordem de entrada [ para a frente | reverso | tranco | acaso ]
especificar a ordem de desvinculação dos dentries, pode ser forward, reverse, stride ou random.
Por padrão, os dentries são desvinculados em ordem aleatória. O pedido de encaminhamento será desvinculado
eles do primeiro ao último, a ordem inversa os desvinculará do último ao primeiro, passo
ordem irá desvinculá-los, contornando a ordem em um padrão quase aleatório e
ordem aleatória selecionará aleatoriamente uma das ordens para frente, reversa ou passo a passo.

--dentras N
criar N dentries por ciclo de thrashing dentry, o padrão é 2048.

--dir N
inicie N workers que criam e removem diretórios usando mkdir e rmdir.

--dir-ops N
parar os thrash workers do diretório após as operações do diretório N bogo.

--dup N
iniciar N trabalhadores que executam dup(2) e então fechar(2) operações em / dev / zero. o
o máximo de aberturas de uma vez é definido pelo sistema, então o teste será executado até este
máximo, ou 65536 descritores de arquivos abertos, o que ocorrer primeiro.

--dup-ops N
pare o dup estressar os trabalhadores após as operações de abertura do N bogo.

--epoll N
iniciar N trabalhadores que realizam várias atividades de estresse de soquete relacionadas usando
epoll_wait(2) para monitorar e lidar com novas conexões. Isso envolve cliente / servidor
processos que realizam conexão rápida, envio / recebimento e desconexão no local
hospedeiro. O uso de epoll permite que um grande número de conexões sejam tratadas com eficiência,
no entanto, isso pode fazer com que a tabela de conexão encha e bloqueie ainda mais
conexões de soquete, portanto, impactando nas estatísticas do epoll bogo op. Para ipv4 e ipv6
domínios, vários servidores são gerados em várias portas. O estressor epoll é para
Linux apenas.

--epoll-domínio D
especificar o domínio a ser usado, o padrão é unix (também conhecido como local). Atualmente ipv4, ipv6
e Unix são suportados.

--epoll-porta P
inicie na porta de soquete P. Para processos de trabalho N epoll, as portas P a (P * 4) -1 são
usado para ipv4, domínios ipv6 e as portas P a P-1 são usadas para o domínio unix.

--epoll-ops N
pare os trabalhadores da epoll após as operações da N bogo.

--eventofd N
iniciar N processos de trabalho pai e filho que leem e gravam mensagens de evento de 8 bytes
entre eles por meio do mecanismo eventfd (somente Linux).

--eventfd-ops N
pare os workers do eventfd após as operações do N bogo.

--exec N
iniciar N trabalhadores continuamente bifurcando crianças que executam o estresse e, em seguida, saem
quase imediatamente.

--exec-ops N
pare os trabalhadores de estresse do executivo após as operações do N bogo.

--exec-max P
criar processos filhos P que executam stress-ng e, em seguida, esperar que eles saiam por
iteração. O padrão é apenas 1; valores mais altos criarão muitos zumbis temporários
processos que estão esperando para serem colhidos. Pode-se potencialmente preencher o processo
tabela usando valores altos para --exec-max e --exec.

-F N, --falocate N
iniciar N workers continuamente em falocação (pré-alocação de espaço de arquivo) e ftuncamento
(arquivo truncado) arquivos temporários. Se o arquivo for maior que o espaço livre,
fallocate irá produzir um erro ENOSPC que é ignorado por este estressor.

--fallocate-bytes N
tamanho de arquivo alocado, o padrão é 1 GB. Pode-se especificar o tamanho em unidades de
Bytes, KBytes, MBytes e GBytes usando o sufixo b, k, m ou g.

--fallocate-ops N
pare os trabalhadores de estresse de fallocate após as operações de fallocate de N bogo.

--culpa N
iniciar N workers que geram falhas de página menores e maiores.

--fault-ops N
pare os operadores de falha de página após as operações de falha de página N bogo.

--fcntl N
iniciar N trabalhadores que executam FCNTL(2) chamadas com vários comandos. Os exercitados
os comandos (se disponíveis) são: F_DUPFD, F_DUPFD_CLOEXEC, F_GETFD, F_SETFD, F_GETFL,
F_SETFL, F_GETOWN, F_SETOWN, F_GETOWN_EX, F_SETOWN_EX, F_GETSIG e F_SETSIG.

--fcntl-ops N
pare os trabalhadores fcntl após as operações N bogo fcntl.

--fiemap N
iniciar N workers, cada um criando um arquivo com muitas extensões alteradas aleatoriamente e tendo
4 processos filho por trabalhador que reúnem as informações de extensão usando o
FS_IOC_FIEMAP ioctl(2).

--fiemap-ops N
parar após as operações do bogo do N fiemap.

--fiemap-size N
especifique o tamanho do arquivo fiemap em bytes. Pode-se especificar o tamanho em unidades
de Bytes, KBytes, MBytes e GBytes usando o sufixo b, k, m ou g. Arquivos maiores
conterá mais extensões, causando mais estresse ao coletar informações de extensão.

--fifo N
inicie N workers que exercem um pipe nomeado transmitindo inteiros de 64 bits.

--fifo-ops N
pare os trabalhadores fifo após as operações de gravação do tubo N bogo.

--fifo-leitores N
para cada trabalhador, crie N fifo leitores de trabalhadores que leiam o pipe nomeado usando
bloqueio de leituras.

--nome do arquivo N
iniciar N workers que exercem a criação de arquivos usando vários nomes de arquivos de comprimento
contendo um intervalo de caracteres de nome de arquivo allower. Isso tentará ver se pode
exceder o comprimento de nome de arquivo permitido pelo sistema de arquivos foi bem como testar vários nomes de arquivos
comprimentos entre 1 e o máximo permitido pelo sistema de arquivos.

--filename-ops N
pare os workers de nome de arquivo após os testes de nome de arquivo do N bogo.

--filename-opções optar
use caracteres no nome do arquivo com base na opção 'opt'. As opções válidas são:

Opção Descrição
opção padrão do probe, analisa o sistema de arquivos em busca de caracteres permitidos válidos
em um nome de arquivo e use-os
posix usa caracteres conforme especificado por The Open Group Base Especificações
Edição 7, POSIX.1-2008, 3.278 Conjunto de caracteres de nome de arquivo portátil
ext use caracteres permitidos pelos sistemas de arquivos ext2, ext3, ext4,
ou seja, qualquer caractere de 8 bits além de NUL e /

--rebanho N
iniciar N workers travando em um único arquivo.

--flock-ops N
pare os trabalhadores de estresse do rebanho após as operações do rebanho N bogo.

-f N, --garfo N
inicie N trabalhadores continuamente bifurcando crianças que saem imediatamente.

--fork-ops N
pare os trabalhadores de estresse do garfo após as operações da N bogo.

--fork-max P
crie P processos filhos e espere que eles saiam por iteração. O padrão
é apenas 1; valores mais altos criarão muitos processos zumbis temporários que são
esperando para ser colhido. Pode-se potencialmente preencher a tabela de processo usando alta
valores para --fork-max e --fork.

--fp-erro N
iniciar N workers que geram exceções de ponto flutuante. Cálculos são realizados
forçar e verificar FE_DIVBYZERO, FE_INEXACT, FE_INVALID, FE_OVERFLOW e
Exceções FE_UNDERFLOW. Erros EDOM e ERANGE também são verificados.

--fp-error-ops N
parar após exceções de ponto flutuante N bogo.

--fstat N
iniciar N workers fstat'ing arquivos em um diretório (o padrão é / dev).

--fstat-ops N
pare os trabalhadores de estresse fstat após as operações N bogo fstat.

--fstat-dir anuário
especifique o diretório para fstat para substituir o padrão de / dev. Todos os arquivos em
o diretório será fstat'd repetidamente.

--futex N
iniciar N trabalhadores que exercem rapidamente a chamada de sistema futex. Cada trabalhador tem dois
processos, um garçom futex e um waker futex. O garçom espera com uma pequena
tempo limite para enfatizar o tempo limite e a espera rápida do futex pesquisado. Este é um Linux
opção de estresse específico.

--futex-ops N
pare os trabalhadores de futex após operações de espera de futex bem-sucedidas de N bogo.

--pegue N
iniciar N trabalhadores que chamam todas as chamadas de sistema get * (2).

--get-ops N
pare de obter trabalhadores após as operações do N bogo get.

--getdent N
iniciar N workers que leem diretórios recursivamente / proc, / Dev /, / Tmp, / sys e / corre
usando getdents e getdents64 (somente Linux).

--getdent-ops N
pare os trabalhadores getdent após as operações N bogo getdent bogo.

--getrandom N
iniciar N workers que obtêm 8192 bytes aleatórios do pool / dev / urandom usando o
aleatório(2) chamada de sistema (somente Linux).

--getrandom-ops N
pare o getrandom workers após as operações do N bogo get.

--lidar N
iniciar N trabalhadores que exercem o nome_para_lidar_em(2) e open_by_handle_at(2)
chamadas de sistema. (Somente Linux).

--handle-ops N
parar após N lidar com operações bogo.

-d N, --hdd N
iniciar N workers continuamente gravando, lendo e removendo arquivos temporários.

--hdd-bytes N
escrever N bytes para cada processo de hdd, o padrão é 1 GB. Pode-se especificar o tamanho
em unidades de Bytes, KBytes, MBytes e GBytes usando o sufixo b, k, m ou g.

--hdd-opções Lista
especifique várias opções de teste de estresse como uma lista separada por vírgulas. As opções são tão
segue:

Opção Descrição
tentativa direta de minimizar os efeitos de cache do I / O. As gravações de E / S de arquivo são
realizada diretamente a partir de buffers de espaço do usuário e síncrona
transferência também é tentada. Para garantir E / S síncrona, também
use a opção de sincronização.
dsync garante que a saída foi transferida para o hardware e arquivo subjacentes
metadados foram atualizados (usando o sinalizador de abertura O_DSYNC). Isto é
equivalente a cada escrever(2) sendo seguido por uma chamada para
fdatasync(2) Veja também a opção fdatasync.
fadv-dontneed aconselhar o kernel a esperar que os dados não sejam acessados ​​no próximo
futuro.
fadv-noreuse aconselha o kernel a esperar que os dados sejam acessados ​​apenas uma vez.
fadv-normal advise kernel não há um padrão de acesso explícito para os dados.
Esta é a suposição de conselho padrão.
fadv-rnd avisa o kernel para esperar padrões de acesso aleatório para os dados.
fadv-seq avisa o kernel para esperar padrões de acesso sequencial para os dados.
fadv-willneed aconselhará o kernel a esperar que os dados sejam acessados ​​no próximo
futuro.

O fsync libera todos os dados modificados no núcleo após cada gravação na saída
dispositivo usando um explícito fsync(2) ligue.
fdatasync semelhante a fsync, mas não libera os metadados modificados, a menos
metadados são necessários para que as leituras de dados posteriores sejam tratadas corretamente.
Isso usa um explícito fdatasync(2) ligue.
A iovec usa E / Ss de buffer múltiplo readv / writeev em vez de ler / escrever.
Em vez de 1 operação de leitura / gravação, o buffer é dividido em um
iovec de 16 buffers.
noatime não atualiza o registro de data e hora do último acesso ao arquivo, isso pode reduzir
gravações de metadados.
sincronizar garante que a saída foi transferida para o hardware subjacente (usando
o sinalizador de abertura O_SYNC). Isso é equivalente a cada escrever(2) sendo
seguido por uma chamada para fsync(2) Veja também a opção fsync.
rd-rnd lêem dados aleatoriamente. Por padrão, os dados gravados não são lidos,
no entanto, esta opção forçará a leitura aleatória.
rd-seq lê dados sequencialmente. Por padrão, os dados gravados não são lidos,
no entanto, esta opção forçará a leitura sequencial.
syncfs grava todas as modificações em buffer de metadados e dados do arquivo no
sistema de arquivos que contém os arquivos do trabalhador hdd.
utimes força a atualização do carimbo de data / hora do arquivo, o que pode aumentar as gravações de metadados.
wr-rnd grava dados aleatoriamente. A opção wr-seq não pode ser usada ao mesmo tempo
tempo.
wr-seq grava dados sequencialmente. Este é o padrão se nenhum modo de gravação for
Especificadas.

Observe que algumas dessas opções são mutuamente exclusivas, por exemplo, pode haver apenas um
método de escrita ou leitura. Além disso, os sinalizadores de fadvise podem ser mutuamente exclusivos, por exemplo
fadv-willneed não pode ser usado com fadv-dontneed.

--hdd-ops N
pare os trabalhadores de estresse de disco rígido após as operações de N bogo.

--hdd-write-size N
especifique o tamanho de cada gravação em bytes. O tamanho pode ser de 1 byte a 4 MB.

--heapsort N
inicie N workers que classificam inteiros de 32 bits usando o heapsort BSD.

--heapsort-ops N
pare os trabalhadores de estresse do heapsort após N bogo heapsorts.

- tamanho maior N
especifique o número de inteiros de 32 bits para classificar, o padrão é 262144 (256 × 1024).

--hsearch N
iniciar N workers que pesquisam uma tabela de hash 80% cheia usando pesquisa(3). Por padrão,
há 8192 elementos inseridos na tabela hash. Este é um método útil para
exercite o acesso à memória e ao cache do processador.

--hsearch-ops N
pare os trabalhadores hsearch depois que as operações N bogo hsearch forem concluídas.

--hsearch-size N
especifique o número de entradas hash a serem inseridas na tabela hash. O tamanho pode ser
de 1K a 4M.

--iche N
iniciar N workers que sobrecarregam o cache de instrução, forçando o cache de instrução
recarrega. Isso é conseguido modificando uma linha de cache de instrução, causando o
processador para recarregá-lo quando chamamos uma função dentro dele. Atualmente apenas
verificado e habilitado para CPUs Intel x86.

--iache-ops N
pare os trabalhadores do icache após a conclusão das operações do N bogo icache.

--inotify N
iniciar N trabalhadores realizando atividades do sistema de arquivos, como criação / exclusão
arquivos / diretórios, arquivos em movimento, etc. para exercitar os vários eventos do inotify
(Somente Linux).

--inotify-ops N
pare de inotificar trabalhadores sob estresse após as operações de N inotify bogo.

-i N, --io N
iniciar N trabalhadores ligando continuamente sincronizar(2) para comprometer o cache do buffer no disco. Esse
pode ser usado em conjunto com as opções --hdd.

--io-ops N
pare de estressar os trabalhadores após as operações da N bogo.

--timer N
iniciar N workers que exercem os cronômetros de intervalo do sistema. Isso configura um
Itimer ITIMER_PROF que gera um sinal SIGPROF. A frequência padrão para o
itimer é 1 MHz, no entanto, o kernel do Linux irá definir isso para não ser mais que o
configuração rápida, portanto, sinais SIGPROF de alta frequência não são normalmente possíveis. UMA
loop ocupado gira gettimer(2) chamadas para consumir CPU e, portanto, decrementar o itimer
com base na quantidade de tempo gasto na CPU e no tempo do sistema.

--timer-ops N
pare os trabalhadores de estresse do itimer após os sinais do N bogo itimer SIGPROF.

--timer-freq F
execute o itimer em F Hz; variam de 1 a 1000000 Hz. Normalmente, a frequência mais alta é
limitado pelo número de tique-taques por segundo, portanto, operar acima de 1000 Hz é
difícil de alcançar na prática.

--kcmp N
iniciar N trabalhadores que usam kcmp(2) comparar os processos pai e filho para determinar
se eles compartilham recursos do kernel (somente Linux).

--kcmp-ops N
pare os workers kcmp após as operações N bogo kcmp.

--chave N
iniciar N workers que criam e manipulam chaves usando add_key(2) e cetctl(2). Como
muitas chaves são criadas conforme o limite por usuário permite e, em seguida, o seguinte keyctl
os comandos são exercidos em cada tecla: KEYCTL_SET_TIMEOUT, KEYCTL_DESCRIBE,
KEYCTL_UPDATE, KEYCTL_READ, KEYCTL_CLEAR e KEYCTL_INVALIDATE.

- key-ops N
pare os trabalhadores-chave após as operações principais do N bogo.

--matar N
iniciar N workers enviando sinais de eliminação SIGUSR1 para um manipulador de sinal SIG_IGN. O máximo de
o tempo do processo terminará no espaço do kernel.

--kill-ops N
pare de matar trabalhadores após as operações de matar do N bogo.

--klog N
iniciar N trabalhadores exercitando o kernel syslog(2) chamada de sistema. Isso tentará
leia o log do kernel com buffers de leitura de vários tamanhos. Linux apenas.

--klog-ops N
pare os trabalhadores klog após N operações syslog.

--de concessão N
iniciar N trabalhadores bloqueando, desbloqueando e cancelando aluguéis por meio do FCNTL(2) F_SETLEASE
Operação. O processo pai bloqueia e desbloqueia continuamente a concessão de um arquivo enquanto
um número selecionável pelo usuário de processos filho abre o arquivo com uma abertura sem bloqueio
para gerar notificações de quebra de aluguel SIGIO para o pai. Este estressor é
disponível apenas se o suporte F_SETLEASE, F_WRLCK e F_UNLCK for fornecido por FCNTL(2).

--lease-ops N
interromper os trabalhadores da locação após as operações da N bogo.

--destruidores de aluguel N
iniciar N processos filho do disjuntor por aluguel. Normalmente uma criança é
bastante para forçar muitos sinais de notificação de quebra de aluguel SIGIO para os pais,
entretanto, esta opção permite especificar mais processos filho, se necessário.

--ligação N
iniciar N workers criando e removendo hardlinks.

--link-ops N
pare os trabalhadores de estresse do link após as operações do N bogo.

--lockbus N
iniciar N workers que bloqueiam e incrementam rapidamente 64 bytes de memória escolhida aleatoriamente
de uma região mmap de 16 MB (apenas CPUs Intel x86). Isso causará falhas de cache
e paralisação de CPUs.

--lockbus-ops N
pare os trabalhadores lockbus após as operações do N bogo.

--lockf N
iniciar N workers que bloqueiam e desbloqueiam aleatoriamente regiões de um arquivo usando o POSIX
bloqueio(3) mecanismo de bloqueio. Cada trabalhador cria um arquivo de 64K e tenta manter um
máximo de 1024 bloqueios simultâneos com um processo filho que também tenta manter 1024
bloqueios simultâneos. Os bloqueios antigos são desbloqueados com base no primeiro a entrar, primeiro a sair.

--lockf-ops N
pare os trabalhadores lockf após as operações do N bogo lockf.

--lockf-nonblock
em vez de usar o bloqueio F_LOCK bloqueio(3) comandos, use F_TLOCK sem bloqueio
comandos e tente novamente se o bloqueio falhou. Isso cria uma sobrecarga extra de chamada de sistema
e a utilização da CPU conforme o número de trabalhadores lockf aumenta e deve aumentar
contenção de bloqueio.

--longjmp N
iniciar N trabalhadores que exercem setjmp(3) /long jmp(3) por loop rápido em longjmp
chamadas.

--longjmp-ops N
pare os trabalhadores de estresse longjmp após operações N bogo longjmp (1 bogo op é 1000
chamadas longjmp).

--search N
iniciar N workers que pesquisam linearmente uma matriz não classificada de inteiros de 32 bits usando
lpesquisar(3). Por padrão, existem 8192 elementos na matriz. Este é um útil
método para exercer o acesso sequencial à memória e ao cache do processador.

--lsearch-ops N
pare os trabalhadores lsearch depois que as operações do N bogo lsearch forem concluídas.

--search-size N
especifique o tamanho (número de inteiros de 32 bits) na matriz a ser pesquisada. O tamanho pode ser
de 1K a 4M.

--malloc N
iniciar N trabalhadores ligando continuamente Malloc(3) calloc(3) realocar(3) e sem(3).
Por padrão, até 65536 alocações podem estar ativas em qualquer ponto, mas isso pode ser
alterado com a opção --malloc-max. Alocação, realocação e liberação são
escolhido ao acaso; 50% do tempo de memória é alocado (via malloc, calloc ou
realocar) e 50% das alocações de tempo são liberadas. Tamanhos de alocação também são
aleatório, com o tamanho máximo de alocação controlado pela opção --malloc-bytes,
o tamanho padrão é 64K. O trabalhador é reiniciado se for morto pela saída de
assassino de memória (OOM).

--malloc-bytes N
máximo por tamanho de alocação / realocação. As alocações são selecionadas aleatoriamente de 1
a N bytes. Pode-se especificar o tamanho em unidades de Bytes, KBytes, MBytes e GBytes
usando o sufixo b, k, m ou g. Tamanhos grandes de alocação fazem com que o alocador de memória
usar mmap(2) em vez de expandir o heap usando brk(2).

--malloc-max N
número máximo de alocações ativas permitidas. As alocações são escolhidas em ramdom e
colocado em um slot de alocação. Porque cerca de 50% / 50% dividido entre alocação e
liberando, normalmente metade dos slots de alocação estão em uso ao mesmo tempo.

--malloc-ops N
parar após as operações N malloc bogo. Uma operação do bogo está relacionada a um sucesso
Malloc(3) calloc(3) ou realocar(3).

--malloc-thresh N
especificar o limite onde malloc usa mmap(2) em vez de sbrk(2) para alocar mais
memória. Isso só está disponível em sistemas que fornecem o GNU C malote(3) afinação
função.

--matriz N
iniciar N workers que executam várias operações de matriz em valores de ponto flutuante. Por
padrão, isso irá exercitar todos os métodos de estresse da matriz, um por um. Um pode
especifique um método de tensão de matriz específico com a opção --matrix-method.

--matrix-ops N
pare os trabalhadores de estresse da matriz após as operações de N bogo.

--matriz-método método
especificar um método de tensão de matriz. Os métodos de tensão da matriz disponíveis são descritos como
segue:

Forma Descrição
tudo itera sobre todos os métodos de estresse de matriz abaixo
adicionar adicionar duas matrizes N × N
copiar copiar uma matriz N × N para outra
div divide uma matriz N × N por um escalar
hadamard Produto de Hadamard de duas matrizes N × N
Frobenius Produto Frobenius de duas matrizes N × N
média média aritmética de duas matrizes N × N
multi multiplica uma matriz N × N por um escalar
produto de produção de duas matrizes N × N
subtraia uma matriz N × N de outra matriz N × N
transpor uma matriz N × N

--matriz-size N
especifique o tamanho N × N das matrizes. Valores menores resultam em um ponto flutuante
estressor de limite de capacidade de computação, em que valores grandes resultam em um cache e / ou
estressor de limite de largura de banda de memória.

--membro N
iniciar N workers que executam a chamada de sistema membarrier (somente Linux).

--membarrier-ops N
pare os trabalhadores do membarrier após as operações do N bogo membarrier.

--memcpy N
iniciar N workers que copiam 2 MB de dados de uma região compartilhada para um buffer usando
memcpy(3) e, em seguida, mova os dados no buffer com memove(3) com 3 diferentes
alinhamentos. Isso exercitará o cache do processador e a memória do sistema.

--memcpy-ops N
pare os trabalhadores de estresse do memcpy após as operações do N bogo memcpy.

--memfd N
iniciar N workers que criam 256 alocações de 1024 páginas usando memfd_create(2) e
ftruncar(2) para alocação e mmap(2) para mapear a alocação no processo
espaço de endereço. (Somente Linux).

--memfd-ops N
pare depois de N criar-memfd(2) operações bogo.

--mergesort N
inicie N workers que classificam inteiros de 32 bits usando o BSD mergesort.

--mergesort-ops N
pare os trabalhadores de estresse do mergesort após o N bogo mergesorts.

--mergesort-size N
especifique o número de inteiros de 32 bits para classificar, o padrão é 262144 (256 × 1024).

--mincore N
iniciar N workers que percorrem toda a memória, 1 página por vez, verificando o
página mapeada e também residente na memória usando mincore(2).

--mincore-ops N
parar após N mincore operações bogo. Um mincore bogo op é equivalente a 1000
mincore(2) chamadas.

--mincore-aleatório
em vez de percorrer as páginas sequencialmente, selecione as páginas aleatoriamente. O escolhido
o endereço é iterado deslocando-o para a direita um lugar e verificado por mincore
até que o endereço seja menor ou igual ao tamanho da página.

--mknod N
iniciar N workers que criam e removem fifos, arquivos vazios e sockets nomeados usando
mknod e desvincular.

--mknod-ops N
pare os trabalhadores do thrash do diretório após as operações N bogo mknod.

--mlock N
iniciar N workers que bloqueiam e desbloqueiam páginas mapeadas de memória usando mllock(2)
Munlock(2) mllockall(2) e Munlockall(2) Isso é alcançado pelo mapeamento de três
páginas contíguas e, em seguida, bloquear a segunda página, garantindo, portanto, não contíguas
as páginas estão bloqueadas. Isso é então repetido até o máximo permitido mlocks ou um
no máximo 262144 mapeamentos são feitos. Em seguida, todos os mapeamentos futuros são mlocked e o
trabalhador tenta mapear 262144 páginas, então todas as páginas são munlocked e as páginas são
não mapeado.

--mlock-ops N
parar após as operações N mlock bogo.

--mmap N
iniciar N trabalhadores ligando continuamente mmap(2) /mapa numérico(2) O mapeamento inicial é um
grande pedaço (tamanho especificado por --mmap-bytes) seguido por 4K pseudo-aleatório
desmapeamentos, em seguida, mapeamentos pseudoaleatórios de 4K e, em seguida, desmapeamentos lineares de 4K. Observação
que isso pode fazer com que os sistemas disparem o assassino OOM do kernel em sistemas Linux, se não
memória física suficiente e swap não está disponível. A opção MAP_POPULATE é usada
para preencher páginas na memória em sistemas que suportam isso. Por padrão, anônimo
mapeamentos são usados, no entanto, as opções --mmap-file e --mmap-async permitem
execute mapeamentos baseados em arquivo, se desejar.

--mmap-ops N
pare os trabalhadores de estresse do mmap após as operações do N bogo.

--mmap-assíncrono
habilitar o mapeamento de memória baseado em arquivo e usar msync'ing assíncrono em cada página, consulte
- arquivo-map.

--mmap-bytes N
alocar N bytes por trabalhador de estresse de mmap, o padrão é 256 MB. Pode-se especificar o
tamanho em unidades de Bytes, KBytes, MBytes e GBytes usando o sufixo b, k, m ou g.

--mmap-arquivo
habilitar o mapeamento de memória baseado em arquivo e, por padrão, usar msync'ing síncrono em cada
Disputas de Comerciais.

--mmap-mprotect
alterar as configurações de proteção em cada página da memória. Cada vez que uma página ou grupo de
as páginas são mapeadas ou remapeadas, então esta opção tornará as páginas somente leitura, gravação
apenas, apenas exec e leitura-gravação.

--mmapfork N
iniciar N trabalhadores em que cada bifurcação de 32 processos filho, cada um dos quais tenta
alocar parte da memória livre deixada no sistema (e tentar evitar qualquer
troca). Os processos filhos sugerem que a alocação será necessária com
louco(2) e, em seguida, defina-o como zero e indique que não é mais necessário com
madvise antes de sair. Isso produz uma quantidade significativa de atividade VM, muito
falhas de cache e com troca mínima.

--mmapfork-ops N
parar após N operações mmapfork bogo.

--mmapmany N
iniciar N workers que tentam criar o máximo permitido de memória por processo
mapeamentos. Isso é conseguido mapeando 3 páginas contíguas e, em seguida, desmapeando o
página do meio, portanto, dividindo o mapeamento em dois. Isso é então repetido até o
mapeamentos máximos permitidos ou um máximo de 262144 mapeamentos são feitos.

--mmapmany-ops N
parar após N mmapmany operações bogo.

--mremap N
iniciar N trabalhadores ligando continuamente mmap(2) mremap(2) e mapa numérico(2) A inicial
mapeamento anônimo é um grande pedaço (tamanho especificado por --mremap-bytes) e então
iterativamente dividido pela metade em tamanho, remapeando todo o caminho até um tamanho de página e, em seguida,
volte ao tamanho original. Este trabalhador está disponível apenas para Linux.

--mremap-ops N
pare os trabalhadores de estresse do mremap após as operações do N bogo.

--mremap-bytes N
alocar inicialmente N bytes por trabalhador de esforço de remapeamento, o padrão é 256 MB. Um pode
especifique o tamanho em unidades de Bytes, KBytes, MBytes e GBytes usando o sufixo b,
k, m ou g.

--msg N
iniciar N processos de remetente e receptor que enviam e recebem mensagens continuamente
usando a mensagem IPC do System V.

--msg-ops N
parar após a conclusão das operações de envio de mensagem do N bogo.

--mq N iniciar N processos de remetente e receptor que enviam e recebem mensagens continuamente
usando filas de mensagens POSIX. (Somente Linux).

--mq-ops N
parar após a conclusão das operações de envio de mensagem do N bogo POSIX.

- tamanho mq N
especifique o tamanho da fila de mensagens POSIX. O tamanho padrão é 10 mensagens e a maioria do Linux
sistemas este é o tamanho máximo permitido para usuários normais. Se o tamanho fornecido for
maior do que o tamanho da fila de mensagens permitido, um aviso é emitido e o
o tamanho máximo permitido é usado.

--legais N
iniciar N cpu consumindo workers que exercem os bons níveis disponíveis. Cada
iteração bifurca um processo filho que percorre todos os níveis legais
executando um loop ocupado por 0.1 segundos por nível e depois sai.

--bom-ops N
pare depois de N nice bogo nice loops

--nulo N
iniciar N workers gravando em / dev / null.

--null-ops N
interromper os workers de estresse nulo após as operações de gravação N / dev / null bogo.

--numa N
iniciar N workers que migram estressores e um buffer mapeado de memória de 4 MB em torno de todos
os nós NUMA disponíveis. Este usa migrar_páginas(2) para mover os estressores e
vincular(2) e mover_páginas(2) para mover as páginas do buffer mapeado. Após cada movimento,
o buffer é escrito para forçar a atividade no barramento, o que resulta em perdas de cache.
Este teste será executado apenas em hardware com NUMA habilitado e mais de 1 nó NUMA.

--numa-ops N
pare os trabalhadores de estresse da NUMA após as operações da N bogo NUMA.

--oom-tubo N
iniciar N trabalhadores que criam tantos tubos quanto permitido e exercem a expansão e
encolhendo os tubos do maior tamanho de tubo até um tamanho de página. Os dados são gravados
nos canos e leia novamente para preencher os amortecedores dos canos. Com o --aggressive
modo habilitado, os dados não são lidos quando os tubos são reduzidos, fazendo com que o kernel
aos processos OOM de forma agressiva. Executar muitas instâncias deste estressor forçará
kernel para processos OOM devido às muitas grandes alocações de buffer de pipe.

--oom-pipe-ops N
pare após as operações de expansão / redução do tubo N bogo.

-o N, --abrir N
iniciar N trabalhadores que executam aberto(2) e então fechar(2) operações em / dev / zero. o
o máximo de aberturas de uma vez é definido pelo sistema, então o teste será executado até este
máximo, ou 65536 descritores de arquivos abertos, o que ocorrer primeiro.

--operações abertas N
pare os trabalhadores de estresse aberto após as operações de abertura de N bogo.

--personalidade N
iniciar N trabalhadores que tentam definir a personalidade e obter todos os recursos disponíveis
tipos de personalidade (tipos de domínio de execução de processo) por meio do personalidade(2) sistema
ligar. (Somente Linux).

- ops de personalidade N
pare os trabalhadores de estresse de personalidade após as operações de personalidade do N bogo.

-p N, --tubo N
iniciar N workers que executam grandes gravações e leituras de pipe para exercitar I / O de pipe.
Isso exercita a escrita e a leitura da memória, bem como a troca de contexto. Cada trabalhador
tem dois processos, um leitor e um escritor.

--pipe-ops N
pare os trabalhadores de estresse do tubo após as operações de gravação do tubo N bogo.

--pipe-tamanho dos dados N
especifica o tamanho em bytes de cada gravação no tubo (intervalo de 4 bytes a 4096
bytes). Definir um tamanho de dados pequeno fará com que mais gravações sejam armazenadas em buffer no
tubo, reduzindo assim a taxa de mudança de contexto entre o gravador de tubo e o tubo
processos de leitura. O tamanho padrão é o tamanho da página.

--tamanho do tubo N
especifica o tamanho do tubo em bytes (para sistemas que suportam o F_SETPIPE_SZ
comando fcntl ()). Definir um tamanho de tubo pequeno fará com que o tubo encha e bloqueie
com mais frequência, aumentando assim a taxa de mudança de contexto entre o escritor de tubos
e os processos do leitor de tubos. O tamanho padrão é 512 bytes.

-P N, --votação N
iniciar N workers que realizam polling de tempo limite zero por meio do pol(2) selecionar(2) e
dormir(3) chamadas. Isso desperdiça tempo do sistema e do usuário sem fazer nada.

--poll-ops N
pare os trabalhadores do estresse da votação após as operações de votação da N bogo.

--procfs N
iniciar N workers que leem arquivos de / proc e ler recursivamente arquivos de
/ proc / self (Somente Linux).

--procfs-ops N
parar a leitura do procfs após as operações de leitura do N bogo. Observe, uma vez que o número de entradas
pode variar entre os kernels, essa métrica do bogo ops é provavelmente muito enganosa.

--pthread N
iniciar N workers que criam e encerram iterativamente vários pthreads (o
o padrão é 1024 pthreads por trabalhador). Em cada iteração, cada pthread recém-criado
espera até que o trabalhador tenha criado todos os pthreads e então todos eles terminam
juntos.

--pthread-ops N
pare os workers de pthread após as operações de criação de N bogo pthread.

--pthread-max N
crie N pthreads por trabalhador. Se o produto do número de pthreads pelo
número de trabalhadores é maior do que o limite flexível de pthreads permitidos, então o
máximo é reajustado até o máximo permitido.

--ptrace N
iniciar N workers que bifurcam e rastreiam chamadas de sistema de um processo filho usando
rastreamento(2).

--ptrace-ops N
pare os trabalhadores do ptracer depois que as chamadas do sistema N bogo forem rastreadas.

-Q, --qsort N
iniciar N workers que classificam inteiros de 32 bits usando qsort.

--qsort-ops N
pare os trabalhadores de estresse qsort após N bogo qsorts.

--qsort-size N
especifique o número de inteiros de 32 bits para classificar, o padrão é 262144 (256 × 1024).

--contingente N
iniciar N trabalhadores que exercem o Q_GETQUOTA, Q_GETFMT, Q_GETINFO, Q_GETSTATS e
Q_SYNC cotação(2) comandos em todos os sistemas de arquivos baseados em blocos montados disponíveis.

--quota-ops N
pare os trabalhadores do estresse por cotas após as operações de N bogo quotactl.

--rdrand N
iniciar N workers que leem o gerador de número aleatório de hardware Intel (Intel
Processadores Ivybridge para cima).

--rdrand-ops N
pare os trabalhadores de estresse do rdrand após as operações do n bogo rdrand (1 bogo op = 2048 aleatório
bits lidos com sucesso).

--Leia adiante N
iniciar N workers que procuram e executam aleatoriamente operações de E / S de leitura / gravação de 512 bytes
em um arquivo com leitura à frente. O tamanho de arquivo padrão é 1 GB. Readaheads e leituras são
agrupado em 16 leituras à frente e, em seguida, 16 leituras.

--readhead-bytes N
definir o tamanho do arquivo readahead, o padrão é 1 GB. Pode-se especificar o tamanho em
unidades de Bytes, KBytes, MBytes e GBytes usando o sufixo b, k, m ou g.

--readhead-ops N
pare os trabalhadores de estresse readahead após as operações de leitura do N bogo.

--remapear N
iniciar N workers que mapeiam 512 páginas e reordenar essas páginas usando o obsoleto
chamada do sistema remap_file_pages(2) Vários reordenamentos de página são executados: encaminhar,
reverso, aleatório e muitas páginas para 1 página.

--remap-ops N
parar após N remapeamento de operações bogo.

-R N, --renomear N
inicie N workers, em que cada um cria um arquivo e o renomeia repetidamente.

--renomear-ops N
pare de renomear trabalhadores de estresse após N bogo renomear operações.

--rlimit N
iniciar N workers que excedem os limites de recursos de CPU e tamanho de arquivo, gerando SIGXCPU
e sinais SIGXFSZ.

--rlimit-ops N
parar após a captura dos sinais SIGXCPU e SIGXFSZ de recursos limitados do N bogo.

--seccomp N
iniciar N workers que exercem filtragem de chamadas do sistema Secure Computing. Cada trabalhador
cria processos filhos que gravam uma mensagem curta em / dev / null e depois sai. 2%
dos processos filhos têm um filtro seccomp que não permite a chamada do sistema de gravação
e, portanto, é eliminado por seccomp com um SIGSYS. Observe que esse estressor pode
gere muitas mensagens de log de auditoria cada vez que o filho é morto.

--seccomp-ops N
pare os trabalhadores de estresse do seccomp após os testes de filtro do N seccomp.

--procurar N
iniciar N workers que procuram e executam aleatoriamente operações de E / S de leitura / gravação de 512 bytes
em um arquivo. O tamanho do arquivo padrão é 16 GB.

--seek-ops N
pare de procurar trabalhadores estressados ​​após as operações de N bogo.

--seek-soco
perfure orifícios de 8K localizados aleatoriamente no arquivo para fazer com que mais extensões forcem um mais
exigente procurar estressor, (somente Linux).

--procurar tamanho N
especifique o tamanho do arquivo em bytes. Tamanhos de arquivo pequenos permitem que o I / O ocorra em
o cache, causando maior carga da CPU. Arquivos grandes forçam mais operações de I / O para
unidade causando mais tempo de espera e mais E / S na unidade. Pode-se especificar o tamanho em
unidades de Bytes, KBytes, MBytes e GBytes usando o sufixo b, k, m ou g.

--sem N
inicie N workers que executam operações de espera e pós de semáforo POSIX. Por padrão,
um pai e 4 filhos são iniciados por trabalhador para fornecer alguma contenção no
semáforo. Isso enfatiza as operações de semáforo rápidas e produz um contexto rápido
comutação.

--sem-ops N
pare os trabalhadores de estresse do semáforo após as operações do semáforo N bogo.

--sem-procs N
iniciar N crianças trabalhadoras por trabalhador para fornecer contenção no semáforo, o
o padrão é 4 e no máximo 64 são permitidos.

--sem-sysv N
iniciar N workers que executam operações de espera e pós de semáforo do System V. Por
padrão, um pai e 4 filhos são iniciados por trabalhador para fornecer alguma contenção
no semáforo. Isso estressa as operações de semáforo rápidas e produz
mudança de contexto.

--sem-sysv-ops N
pare os trabalhadores de estresse do semáforo após as operações do semáforo do N bogo System V.

--sem-sysv-procs N
iniciar N processos filho por trabalhador para fornecer contenção no semáforo System V,
o padrão é 4 e no máximo 64 são permitidos.

--Enviar arquivo N
iniciar N workers que enviam um arquivo vazio para / dev / null. Esta operação gasta quase
o tempo todo no kernel. O tamanho padrão do sendfile é 4 MB. O sendfile
as opções são apenas para Linux.

--sendfile-ops N
pare os workers do sendfile após as operações N sendfile bogo.

--enviar tamanho do arquivo S
especifique o tamanho a ser copiado com cada chamada sendfile. O tamanho padrão é 4 MB. Um
pode especificar o tamanho em unidades de Bytes, KBytes, MBytes e GBytes usando o sufixo
b, k, m ou g.

--shm N
iniciar N workers que abrem e alocam objetos de memória compartilhada usando o POSIX compartilhado
interfaces de memória. Por padrão, o teste irá criar e destruir repetidamente 32
objetos de memória compartilhada, cada um com 8 MB de tamanho.

--shm-ops N
pare após a conclusão das operações de criação e destruição de memória compartilhada N POSIX.

--shm-bytes N
especifique o tamanho dos objetos de memória compartilhada POSIX a serem criados. Pode-se especificar
o tamanho em unidades de Bytes, KBytes, MBytes e GBytes usando o sufixo b, k, m ou
g.

--shm-objs N
especifique o número de objetos de memória compartilhada a serem criados.

--shm-sysv N
iniciar N workers que alocam memória compartilhada usando a memória compartilhada do System V
interface. Por padrão, o teste irá criar e destruir repetidamente 8 memórias compartilhadas
segmentos, cada um com 8 MB de tamanho.

--shm-sysv-ops N
pare depois que as operações de criação e destruição de memória compartilhada N forem concluídas.

--shm-sysv-bytes N
especifique o tamanho do segmento de memória compartilhada a ser criado. Pode-se especificar o
tamanho em unidades de Bytes, KBytes, MBytes e GBytes usando o sufixo b, k, m ou g.

--shm-sysv-segs N
especifique o número de segmentos de memória compartilhada a serem criados.

--sigfd N
iniciar N workers que geram sinais SIGRT e são gerenciados por leituras por uma criança
processo usando um descritor de arquivo configurado usando sinal fd(2) (Somente Linux). Isso vai
gerar uma carga pesada de alternância de contexto quando todas as CPUs estiverem totalmente carregadas.

--sigfd-ops
pare os trabalhadores sigfd depois que os sinais N bogo SIGUSR1 forem enviados.

--sigfpe N
iniciar N trabalhadores que rapidamente causam divisão por zero falhas SIGFPE.

--sigfpe-ops N
pare os trabalhadores de estresse da sigfpe após as falhas do N bogo SIGFPE.

--assinando N
iniciar N workers que verificam se os sinais SIGUSR1 estão pendentes. Este estressor mascara
SIGUSR1, gera um sinal SIGUSR1 e usa assinando(2) para ver se o sinal é
pendente. Em seguida, ele desmascara o sinal e verifica se o sinal não está mais pendente.

--signpending-ops N
pare de suspender os trabalhadores de estresse após o N bogo suspender as verificações de pendência / desconexão.

--sigsegv N
inicie N workers que criam e detectam falhas de segmentação rapidamente.

--sigsegv-ops N
pare os trabalhadores de estresse sigsegv após falhas de segmentação N bogo.

--sigsuspender N
iniciar N workers em que cada um gera 4 processos filho que esperam por um SIGUSR1
sinal do pai usando suspender(2) O pai envia sinais SIGUSR1 para
cada criança em rápida sucessão. Cada ativação sigsuspend é contada como um bogo
operação.

--sigsusspend-ops N
pare os trabalhadores do estresse do sigsuspend após os wakeups do N bogo sigsuspend.

--sigq N
iniciar N workers que enviam rapidamente sinais SIGUSR1 usando fila de espera(3) para criança
processos que esperam pelo sinal via sigwaitinfo(2).

--sigq-ops N
pare os trabalhadores de estresse sigq após as operações de envio de sinal N bogo.

--dormir N
iniciar N workers que geram vários threads em que cada um executa vários sleeps
de intervalos de 1 us a 0.1 s. Isso cria várias opções de contexto e temporizador
interrupções.

--sleep-ops N
parar após as operações N sleep bogo.

--sleep-max P
iniciar P threads por trabalhador. O padrão é 1024, o máximo permitido é 30000.

-S N, --meia N
iniciar N trabalhadores que realizam várias atividades de estresse de soquete. Isso envolve um par
de processos cliente / servidor executando conexão rápida, envio e recebimento e
desconecta no host local.

--sock-domínio D
especificar o domínio a ser usado, o padrão é ipv4. Atualmente ipv4, ipv6 e unix são
suportado.

--sock-nodelay
Isso desativa o algoritmo TCP Nagle, de modo que os segmentos de dados são sempre enviados assim que
possível. Isso impede que os dados sejam armazenados em buffer antes de serem transmitidos, portanto
resultando em uma utilização de rede mais pobre e mais trocas de contexto entre os
remetente e destinatário.

--sock-porta P
inicie na porta de soquete P. Para N processos de trabalho de soquete, as portas P a P-1 são usadas.

--sock-ops N
pare os trabalhadores de estresse de soquete após as operações de N bogo.

--sock-opções [ enviar | enviar mensagem | enviarmmsg ]
por padrão, as mensagens são enviadas usando enviar(2) Esta opção permite especificar o
método de envio usando enviar(2) enviar mensagem(2) ou enviarmmsg(2) Observe que sendmmsg é
disponível apenas para sistemas Linux que suportam esta chamada de sistema.

--sockfd N
iniciar N workers que passam descritores de arquivo por um soquete de domínio UNIX usando o
CMSG(3) mecanismo de dados auxiliares. Para cada trabalhador, par de processos cliente / servidor
são criados, o servidor abre tantos descritores de arquivo em / dev / null quanto possível e
passando-os pelo soquete para um cliente que os lê dos dados CMSG e
fecha imediatamente os arquivos.

--sockfd-ops N
pare os trabalhadores de estresse sockfd após as operações do N bogo.

- par de meias N
iniciar N workers que executam leituras / gravações de E / S de pares de soquetes. Isso envolve um par de
processos cliente / servidor executando operações de E / S de soquete de tamanho aleatório.

- pares de meias-ops N
pare os trabalhadores de estresse do par de soquetes após as operações de N bogo.

--spawn N
iniciar N trabalhadores continuamente gerar crianças usando posix_spawn(3) aquele estresse executivo
e saia quase imediatamente.

--spawn-ops N
interromper a geração de trabalhadores com estresse após a geração de N bogo.

-- emenda N
mover dados de / dev / zero para / dev / null por meio de um tubo sem qualquer cópia entre
espaço de endereço do kernel e espaço de endereço do usuário usando Emparelhar(2) Isso só está disponível
para o Linux.

--splice-ops N
pare após as operações de emenda do N bogo.

--splice-bytes N
transferir N bytes por chamada de emenda, o padrão é 64K. Pode-se especificar o tamanho em
unidades de Bytes, KBytes, MBytes e GBytes usando o sufixo b, k, m ou g.

--pilha N
iniciar N workers que rapidamente causam e detectam estouros de pilha pelo uso de alocar(3).

--stack-full
a ação padrão é tocar a página mais baixa em cada alocação de pilha. Isto
opção toca todas as páginas, preenchendo a nova alocação de pilha com zeros que
força a alocação de páginas físicas e, portanto, é mais agressivo.

--stack-ops N
pare os trabalhadores de estresse da pilha após o estouro da pilha do N bogo.

--str N
iniciar N workers que exercem várias funções de string libc em strings aleatórias.

--str-método strfunc
selecione uma função de string libc específica para enfatizar. Funções de string disponíveis para
stress são: all, index, rindex, strcasecmp, strcat, strchr, strcoll, strcmp,
strcpy, strlen, strncasecmp, strncat, strncmp, strrchr e strxfrm. Ver corda(3)
para obter mais informações sobre essas funções de string. O método 'all' é o padrão
e exercitará todos os métodos de string.

--str-ops N
parar após as operações de string N bogo.

--Stream N
iniciar N trabalhadores exercitando um estressor de largura de banda de memória vagamente com base no STREAM
Ferramenta de benchmarking "Largura de banda de memória sustentável em computadores de alto desempenho" por
John D. McCalpin, Ph.D. Este estressor aloca buffers que são pelo menos 4 vezes
o tamanho do cache L2 da CPU e continuamente executa rodadas de seguir
cálculos em grandes matrizes de números de ponto flutuante de precisão dupla:

Divisão de Descrição
cópia c [i] = a [i]
escala b [i] = escalar * c [i]
adicione c [i] = a [i] + b [i]
tríade a [i] = b [i] + (c [i] * escalar)

Uma vez que isso é vagamente baseado em uma variante do código de benchmark STREAM, NÃO
apresentar resultados com base nisso, pois se destina a enfatizar apenas para enfatizar
memória e computação e NÃO se destina a STREAM precisamente ajustado ou não ajustado
benchmarking qualquer. Use a ferramenta oficial de benchmarking STREAM se desejar
benchmarks STREAM precisos e padronizados.

--stream-ops N
parar após as operações N stream bogo, onde uma operação bogo é uma rodada de cópia,
escalar, adicionar e operações de tríade.

--stream-l3-tamanho N
Especifique o tamanho do cache de nível 3 da CPU em bytes. Pode-se especificar o tamanho em unidades de
Bytes, KBytes, MBytes e GBytes usando o sufixo b, k, m ou g. Se o cache L3
tamanho não for fornecido, então o stress-ng tentará determinar o tamanho do cache, e
na falta disso, o tamanho padrão será de 4 MB.

-s N, --trocar N
iniciar N workers que enviam mensagens via pipe para um filho para forçar a troca de contexto.

--switch-ops N
pare os workers de troca de contexto após as operações do N bogo.

--link simbólico N
inicie N workers criando e removendo links simbólicos.

--simlink-ops N
pare os trabalhadores de estresse do link simbólico após as operações do N bogo.

--arquivo de sincronização N
iniciar N workers que realizam uma série de sincronizações de dados em um arquivo usando
intervalo_de_arquivos_de_sincronização(2) Três combinações de sincronizações são realizadas, do início ao fim do
o arquivo, do final do arquivo ao início, e uma mistura aleatória. Uma seleção aleatória
de tipos de sincronização válidos são usados, cobrindo o SYNC_FILE_RANGE_WAIT_BEFORE,
SYNC_FILE_RANGE_WRITE e SYNC_FILE_RANGE_WAIT_AFTER bits de sinalizador.

--sync-file-ops N
pare os workers de arquivo de sincronização após as operações de sincronização do N bogo.

--sync-file-bytes N
especifique o tamanho do arquivo a ser sincronizado. Pode-se especificar o tamanho em unidades de
Bytes, KBytes, MBytes e GBytes usando o sufixo b, k, m ou g.

--sysinfo N
inicie N workers que leem continuamente o sistema e processam informações específicas.
Isso lê o usuário do processo e os tempos do sistema usando o vezes(2) chamada de sistema. Por
Sistemas Linux, ele também lê estatísticas gerais do sistema usando o Sysinfo(2) sistema
chamar e também as estatísticas do sistema de arquivos para todos os sistemas de arquivos montados usando
estatísticas(2).

--sysinfo-ops N
pare os trabalhadores sysinfo após as operações do N bogo.

--sysfs N
iniciar N workers que leem recursivamente arquivos de / sys (Somente Linux). Isso pode causar
drivers de kernel específicos para emitir mensagens no log do kernel.

--sys-ops N
parar a leitura do sysfs após as operações de leitura do N bogo. Observe, uma vez que o número de entradas
pode variar entre os kernels, essa métrica do bogo ops é provavelmente muito enganosa.

- dedo N
mover dados de um processo de gravação para um processo de leitura através de canais e para / dev / null
sem qualquer cópia entre o espaço de endereço do kernel e o espaço de endereço do usuário usando
tee(2) Disponível apenas para Linux.

--se-ops N
pare após as operações do N bogo tee.

-T N, --cronômetro N
iniciar N workers criando eventos de timer em uma taxa padrão de 1 MHz (somente Linux); isto
pode criar milhares de interrupções de relógio temporizador. Cada evento de cronômetro é capturado
por um manipulador de sinal e contado como um bogo timer op.

--timer-ops N
parar o cronômetro sobrecarregar os trabalhadores após eventos do cronômetro N bogo (somente Linux).

--timer-freq F
executar temporizadores em F Hz; variam de 1 a 1000000000 Hz (somente Linux). Selecionando um
estresse de frequência apropriado pode gerar centenas de milhares de interrupções
por segundo.

--timer-rand
selecione uma frequência do temporizador com base na frequência do temporizador +/- 12.5% de variação aleatória.
Isso tenta forçar mais variabilidade no intervalo do cronômetro para fazer o agendamento
menos previsível.

--timerfd N
iniciar N workers criando eventos timerfd em uma taxa padrão de 1 MHz (somente Linux);
isso pode criar muitos milhares de eventos de relógio temporizador. Os eventos do cronômetro são aguardados
no descritor de arquivo do cronômetro usando selecionar(2) e então lido e contado como um bogo
timerfd op.

--timerfd-ops N
stop timerfd sobrecarrega os workers após eventos N bogo timerfd (somente Linux).

--timerfd-freq F
executar temporizadores em F Hz; variam de 1 a 1000000000 Hz (somente Linux). Selecionando um
estresse de frequência apropriado pode gerar centenas de milhares de interrupções
por segundo.

--timerfd-rand
selecione uma frequência do temporizadorfd com base na frequência do temporizador +/- 12.5% aleatório
jitter. Isso tenta forçar mais variabilidade no intervalo do cronômetro para tornar o
agendamento menos previsível.

--tsc N
iniciar N workers que leem o Time Stamp Counter (TSC) 256 vezes por iteração de loop
(operação bogo). Disponível apenas em plataformas Intel x86.

--tsc-ops N
pare os trabalhadores tsc depois que as operações N bogo forem concluídas.

--search N
iniciar N workers que inserem, procuram e excluem inteiros de 32 bits em uma árvore binária
utilização pesquisa(3) encontrar(3) e apagar(3). Por padrão, existem 65536 randomizados
inteiros usados ​​na árvore. Este é um método útil para exercitar o acesso aleatório de
memória e cache do processador.

--tsearch-ops N
pare os trabalhadores tsearch depois que as operações da árvore N bogo forem concluídas.

--tsearch-size N
especifique o tamanho (número de inteiros de 32 bits) na matriz a ser pesquisada. O tamanho pode ser
de 1K a 4M.

--udp N
iniciar N workers que transmitem dados usando UDP. Isso envolve um par de cliente / servidor
processos que realizam conexão rápida, envio e recebimento e desconexão no local
hospedeiro.

--udp-domínio D
especificar o domínio a ser usado, o padrão é ipv4. Atualmente ipv4, ipv6 e unix são
suportado.

--udp-lite
use o protocolo UDP-Lite (RFC 3828) (somente para domínios ipv4 e ipv4).

--udp-ops N
pare os trabalhadores de estresse udp após as operações do N bogo.

--udp-porta P
inicie na porta P. Para processos de trabalho N udp, as portas P a P-1 são usadas. Por padrão,
as portas 7000 para cima são usadas.

--udp-inundação N
inicie N workers que tentam inundar o host com pacotes UDP para portas aleatórias.
O endereço IP dos pacotes não está falsificado. Isso está disponível apenas em
sistemas que suportam AF_PACKET.

--udp-flood-domínio D
especificar o domínio a ser usado, o padrão é ipv4. Atualmente ipv4 e ipv6 são
suportado.

--udp-flood-ops N
pare os trabalhadores do estresse da inundação udp após as operações do N bogo.

- não compartilhar N
iniciar N trabalhadores em que cada bifurcação de 32 processos filho, cada um dos quais exercita o
descompartilhar(2) chamada do sistema desassociando partes do contexto de execução do processo.
(Somente Linux).

--unshare-ops N
parar após as operações de cancelamento de compartilhamento do N bogo.

-u N, --urandom N
iniciar N workers lendo / dev / urandom (somente Linux). Isto irá carregar o kernel aleatoriamente
fonte do número.

--urandom-ops N
pare os trabalhadores de estresse urandom após as operações de leitura do bogo N urandom (somente Linux).

--userfaultfd N
iniciar N workers que geram falhas de página de gravação em um pequeno mapeado anonimamente
região de memória e lidar com essas falhas usando o tratamento de falhas de espaço do usuário através do
mecanismo userfaultfd. Isso irá gerar uma grande quantidade de falhas de página principais e
também muda de contexto durante o tratamento das falhas de página. (Somente Linux).

--userfaultfd-ops N
parar userfaultfd sobrecarregar os trabalhadores após N falhas de página.

--userfaultfd-bytes N
mmap N bytes por userfaultfd trabalhador para falha de página, o padrão é 16 MB.
especifique o tamanho em unidades de Bytes, KBytes, MBytes e GBytes usando o sufixo b,
k, m ou g.

--utime N
iniciar N workers atualizando os carimbos de data / hora do arquivo. Isso é principalmente limitado pela CPU quando o padrão
é usado porque o sistema libera alterações de metadados apenas periodicamente.

--utime-ops N
pare os trabalhadores de estresse após as operações do N utime Bogo.

--utime-fsync
força as alterações de metadados em cada atualização de carimbo de data / hora do arquivo a serem descarregadas no disco. Isto
força o teste a se tornar limitado por E / S e resultará em muitas gravações de metadados sujos.

--vecmath N
iniciar N trabalhadores que realizam várias operações matemáticas inteiras sem sinal em vários
Vetores de 128 bits. Uma mistura de operações matemáticas vetoriais são realizadas nas seguintes
vetores: 16 × 8 bits, 8 × 16 bits, 4 × 32 bits, 2 × 64 bits. As métricas produzidas
por esta mistura dependem da arquitetura do processador e das otimizações matemáticas vetoriais
produzido pelo compilador.

--vecmath-ops N
parar após as operações matemáticas de inteiro do vetor N bogo.

--vfork N
inicie N trabalhadores continuamente vforking crianças que saem imediatamente.

--vfork-ops N
pare os trabalhadores de estresse do vfork após as operações do N bogo.

--vfork-max P
crie processos P e espere que eles saiam por iteração. O padrão é
apenas 1; valores mais altos irão criar muitos processos zumbis temporários que estão esperando
para ser colhido. Pode-se potencialmente preencher a tabela de processo usando valores altos
para --vfork-max e --vfork.

-m N, --vm N
iniciar N trabalhadores ligando continuamente mmap(2) /mapa numérico(2) e escrever para o alocado
memória. Observe que isso pode fazer com que os sistemas disparem o assassino OOM do kernel no Linux
sistemas se não houver memória física suficiente e a troca não estiver disponível.

--vm-bytes N
bytes N de mmap por trabalhador vm, o padrão é 256 MB. Pode-se especificar o tamanho em unidades
de Bytes, KBytes, MBytes e GBytes usando o sufixo b, k, m ou g.

--vm-stride N
obsoleto desde a versão 0.03.02

--vm-ops N
pare os trabalhadores vm após as operações do N bogo.

--vm-pendurar N
sleep N segundos antes de remover o mapeamento da memória, o padrão é zero segundos. Especificando 0
fará uma espera infinita.

--vm-keep
não desmapear e mapear continuamente a memória, apenas continue a reescrevê-la.

--vm-bloqueado
Trave as páginas da região mapeada na memória usando mmap MAP_LOCKED (desde o Linux
2.5.37). Isso é semelhante ao bloqueio de memória, conforme descrito em mllock(2).

--vm-método m
especifique um método de estresse vm. Por padrão, todos os métodos de estresse são exercidos
sequencialmente, no entanto, pode-se especificar apenas um método a ser usado, se necessário. Cada
dos trabalhadores vm têm 3 fases:

1. Inicializado. A região mapeada de memória anonimamente é definida para um padrão conhecido.

2. Exercitado. A memória é modificada de uma maneira previsível conhecida. Alguns funcionários vm alteram
memória sequencialmente, alguns usam passos pequenos ou grandes para percorrer a memória.

3. Verificado. A memória modificada é verificada para ver se corresponde ao esperado
resultado.

Os métodos vm contendo 'primo' em seu nome têm uma passada do maior primo
menos de 2 ^ 64, permitindo que percorram completamente a memória e toquem em todos
locais apenas uma vez, sem tocar nas células de memória ao lado de cada um
de outros. Esta estratégia exercita o cache e a não localidade da página.

Uma vez que a memória que está sendo exercida é virtualmente mapeada, não há garantia de
tocar em endereços de página em qualquer ordem física específica. Esses trabalhadores não deveriam
ser usado para testar se toda a memória do sistema está funcionando corretamente, use ferramentas
como memtest86 em vez disso.

Os métodos de estresse vm têm como objetivo exercitar a memória de forma a possivelmente encontrar
problemas de memória e tentar forçar erros térmicos.

Os métodos de estresse vm disponíveis são descritos a seguir:

Forma Descrição
all iterate sobre todos os métodos de estresse de VM, conforme listado abaixo.
inverta sequencialmente, trabalhe na memória 8 vezes, cada vez apenas
um bit na memória invertido (invertido). Isso irá efetivamente
inverta cada byte em 8 passagens.
galpat-0 padrão galopante zeros. Isso define todos os bits para 0 e vira
apenas 1 em 4096 bits para 1. Em seguida, verifica se o 1s
são puxados para 0 por seus vizinhos ou do
vizinhos foram aumentados para 1.
galpat-1 padrão galopante. Isso define todos os bits para 1 e vira
apenas 1 em 4096 bits para 0. Em seguida, verifica se o 0s
são puxados para 1 por seus vizinhos ou dos vizinhos
foram reduzidos a 0.
cinza preenche a memória com códigos cinza sequenciais (estes apenas
mude 1 bit por vez entre bytes adjacentes) e então
verifique se eles estão configurados corretamente.
O incdec funciona sequencialmente através da memória duas vezes, a primeira passagem
incrementa cada byte por um valor específico e o segundo
passe decrementos de cada byte de volta ao valor inicial original.
O valor de incremento / decremento muda a cada invocação de
o estressor.
inc-nybble inicializa a memória para um valor definido (que muda em cada
invocação do estressor) e, em seguida, trabalhar sequencialmente
através de cada byte incrementando os 4 bits inferiores em 1 e
os 4 primeiros bits por 15.
O conjunto aleatório funciona sequencialmente por meio da memória na configuração de blocos de 64 bits
bytes no bloco para o mesmo valor aleatório de 8 bits. O
o valor aleatório muda em cada pedaço. Verifique se os valores
não mudaram.
rand-sum definir sequencialmente toda a memória para valores aleatórios e, em seguida,
soma o número de bits que mudaram do
valores ajustados originais.
read64 ler sequencialmente a memória usando leituras de 32 x 64 bits por bogo
ciclo. Cada loop equivale a uma operação bogo. Isto
exercita leituras de memória bruta.
ror preencher a memória com um padrão aleatório e, em seguida, sequencialmente
gire 64 bits de memória em um bit e, em seguida, verifique o
carga final / rotação / valores armazenados.
troca de memória de preenchimento em blocos de 64 bytes com padrões aleatórios. Então
troque cada pedaço de 64 com um pedaço escolhido aleatoriamente. Finalmente,
reverta a troca para colocar os pedaços de volta ao original
coloque e verifique se os dados estão corretos. Estes exercícios
carga / armazenamento de memória adjacente e aleatória.
mover-inv preencher sequencialmente a memória de 64 bits de memória por vez com
valores aleatórios e, em seguida, verifique se a memória está configurada
corretamente. Em seguida, inverta sequencialmente cada padrão de 64 bits
e verifique novamente se a memória está configurada conforme o esperado.

o módulo-x preenche a memória em 23 iterações. Cada iteração inicia um
byte mais adiante desde o início da memória e etapas
junto em passadas de 23 bytes. Em cada passada, o primeiro byte é
definido para um padrão aleatório e todos os outros bytes são definidos para o
inverso. Em seguida, ele verifica se o primeiro byte contém o
padrão aleatório esperado. Este exercício armazena / leituras de cache
bem como ver se as células vizinhas influenciam cada
outro.
prime-0 itera 8 vezes percorrendo a memória em muito grande
os primeiros passos apagando apenas um pouco de cada vez em cada byte.
Em seguida, verifique se todos os bits estão configurados para zero.
prime-1 itera 8 vezes percorrendo a memória em muito grande
configuração dos passos principais apenas um pouco por vez em cada byte.
Em seguida, verifique se todos os bits estão configurados para um.
prime-grey-0 primeiro passo através da memória em grandes passadas prime
limpar apenas um bit (com base em um código cinza) em cada byte.
Em seguida, repita isso, mas limpe os outros 7 bits. Em seguida, verifique para
veja se todos os bits estão definidos para zero.
prime-grey-1 primeiro passo através da memória em grandes passadas prime
configuração apenas no bit (com base em um código cinza) em cada byte.
Em seguida, repita isso, mas defina os outros 7 bits. Em seguida, verifique para
veja se todos os bits estão configurados para um.
Rowhammer tenta forçar a corrupção da memória usando a memória do Rowhammer
estressor. Isso busca dois inteiros de 32 bits da memória e
força uma liberação de cache nos dois endereços várias vezes.
Isso é conhecido por forçar a inversão de bits em alguns hardwares,
especialmente com ciclos de atualização de memória de baixa frequência.
percorrer 0d para cada byte na memória, percorrer cada linha de dados
configurando-os para baixo (e os outros são configurados para alto) e verifique
que o valor escrito é o esperado. Isso verifica se houver
as linhas de dados estão travadas.
percorrer 1d para cada byte na memória, percorrer cada linha de dados
configurando-os para alto (e os outros são configurados para baixo) e verifique
que o valor escrito é o esperado. Isso verifica se houver
as linhas de dados estão travadas.
walk-0a no mapeamento de memória dado, trabalhar através de uma gama de
endereços especialmente escolhidos trabalhando através de linhas de endereço para
veja se alguma linha de endereço está presa na parte inferior. Isso funciona melhor
com endereçamento de memória física, no entanto, exercitando estes
endereços virtuais também têm algum valor.
walk-1a no mapeamento de memória dado, trabalhar através de uma gama de
endereços especialmente escolhidos trabalhando através de linhas de endereço para
veja se alguma linha de endereço está presa no alto. Isso funciona melhor
com endereçamento de memória física, no entanto, exercitando estes
endereços virtuais também têm algum valor.
write64 grava sequencialmente na memória usando gravações de 32 x 64 bits por bogo
ciclo. Cada loop equivale a uma operação bogo. Isto
exercita as gravações da memória bruta. Observe que as gravações de memória são
não verificado no final de cada iteração de teste.
zero-um define todos os bits de memória para zero e, em seguida, verifique se algum bit está
não zero. Em seguida, defina todos os bits de memória para um e verifique se
quaisquer bits não são um.

--vm-popular
preencher as tabelas de página (pré-padrão) para os mapeamentos de memória; isso pode sobrecarregar a troca.
Disponível apenas em sistemas que suportam MAP_POPULATE (desde Linux 2.5.46).

--vm-rw N
iniciar N workers que transferem memória para / de um pai / filho usando
process_vm_writev(2) e process_vm_readv(2) Este recurso só é compatível com
Linux. As transferências de memória são verificadas apenas se a opção --verify estiver habilitada.

--vm-rw-ops N
pare os workers vm-rw após N leituras / gravações de memória.

--vm-rw-bytes N
mmap N bytes por trabalhador vm-rw, o padrão é 16 MB. Pode-se especificar o tamanho em
unidades de Bytes, KBytes, MBytes e GBytes usando o sufixo b, k, m ou g.

--vm-splice N
mover dados da memória para / dev / null por meio de um tubo sem qualquer cópia entre
espaço de endereço do kernel e espaço de endereço do usuário usando vmsplice(2) e Emparelhar(2). Esse
está disponível apenas para Linux.

--vm-splice-ops N
pare após as operações de emenda Vm do N bogo.

--vm-splice-bytes N
transferir N bytes por chamada vmsplice, o padrão é 64K. Pode-se especificar o tamanho em
unidades de Bytes, KBytes, MBytes e GBytes usando o sufixo b, k, m ou g.

--esperar N
iniciar N trabalhadores que geram dois filhos; um gira em um pausa(2) loop, o
outro para continuamente e continua o primeiro. O processo de controle aguarda
a primeira criança a ser retomada até o parto do SIGCONT usando garçonete(2) e
garçonete(2).

--wait-ops N
parar após as operações de espera do N bogo.

--wcs N
iniciar N workers que exercem várias funções de string de caracteres ampla da libc em
strings aleatórias.

--wcs-método wcsfunc
selecione uma função de string de caracteres ampla da libc específica para enfatizar. String disponível
funções a serem enfatizadas são: all, wcscasecmp, wcscat, wcschr, wcscoll, wcscmp, wcscpy,
wcslen, wcsncasecmp, wcsncat, wcsncmp, wcsrchr e wcsxfrm. O método 'todos' é
o padrão e exercitará todos os métodos de string.

--wcs-ops N
parar após as operações de cadeia de caracteres ampla do N bogo.

--xattr N
iniciar N workers que criam, atualizam e excluem lotes de atributos estendidos em um
arquivo.

--xattr-ops N
parar após as operações de atributo estendido do N bogo.

-y N, --colheita N
iniciar N trabalhadores que chamam rendimento_sched(2) Este estressor garante que pelo menos 2
processos filhos por exercício de CPU escudo_produto(2) não importa quantos trabalhadores são
especificado, garantindo assim sempre a troca rápida de contexto.

- ops de rendimento N
pare os trabalhadores de estresse de rendimento após N rendimento_sched(2) operações bogo.

--zero N
iniciar N workers lendo / dev / zero.

- zero-ops N
pare os trabalhadores com estresse zero após as operações de leitura N / dev / zero bogo.

--zlib N
iniciar N workers compactando e descompactando dados aleatórios usando zlib. Cada trabalhador
tem dois processos, um que compacta dados aleatórios e os canaliza para outro processo
que descompacta os dados. Este estressor exercita CPU, cache e memória.

--zlib-ops N
parar após as operações de compressão N bogo, cada operação de compressão bogo é um
compactação de 64 K de dados aleatórios no nível de compactação mais alto.

--zumbi N
iniciar N workers que criam processos zumbis. Isso tentará criar rapidamente um
padrão de 8192 processos filho que morrem imediatamente e esperam em um estado zumbi
até que sejam colhidos. Assim que o número máximo de processos for alcançado (ou bifurcação
falha porque um atingiu o número máximo permitido de filhos) o mais velho
criança é colhida e um novo processo é então criado de uma maneira first-in first-out,
e depois repetido.

--zombie-ops N
pare os trabalhadores do estresse zumbi após as operações zumbis N bogo.

--zombie-max N
tente criar até N processos zumbis. Isso pode não ser alcançado se o sistema
limite é menor que N.

EXEMPLOS

estresse-ng --cpu 4 --io 2 --vm 1 --vm-bytes 1G --timeout 60s

é executado por 60 segundos com 4 estressores de CPU, 2 estressores io e 1 estressor vm usando
1 GB de memória virtual.

estresse-ng --cpu 8 --cpu-ops 800000

executa 8 estressores de CPU e para após 800000 operações bogo.

stress-ng --sequencial 2 --timeout 2m --metrics

execute 2 instâncias simultâneas de todos os estressores sequencialmente, um por um, cada para
2 minutos e resuma com métricas de desempenho no final.

estresse-ng --cpu 4 --cpu-method fft --cpu-ops 10000 --metrics-brief

execute 4 estressores de CPU FFT, pare após 10000 operações bogo e produza um resumo
apenas para os resultados FFT.

estresse-ng --cpu 0 --cpu-método tudo -t 1h

execute estressores de CPU em todas as CPUs on-line trabalhando em todas as CPUs disponíveis
estressores por 1 hora.

stress-ng --todos 4 - tempo limite 5m

execute 4 instâncias de todos os estressores por 5 minutos.

estresse-ng --random 64

execute 64 estressores que são escolhidos aleatoriamente entre todos os estressores disponíveis.

estresse-ng --cpu 64 --cpu-method todos --verify -t 10m --metrics-brief

execute 64 instâncias de todos os diferentes estressores de CPU e verifique se o
os cálculos estão corretos por 10 minutos com um resumo das operações do bogo no final.

stress-ng - sequencial 0 -t 10m

execute todos os estressores um por um por 10 minutos, com o número de instâncias de
cada estressor correspondendo ao número de CPUs online.

stress-ng --sequencial 8 --classe io -t 5m --times

execute todos os estressores da classe IO, um por um, por 5 minutos cada, com 8
instâncias de cada estressor em execução simultaneamente e mostram a utilização geral do tempo
estatísticas no final da execução.

stress-ng --all 0 --maximize --agressive

execute todos os estressores (1 instância de cada por CPU) simultaneamente, maximize o
configurações (tamanhos de memória, alocações de arquivos, etc.) e selecione a maioria
opções exigentes / agressivas.

stress-ng --random 32 -x numa, hdd, chave

execute 32 estressores selecionados aleatoriamente e exclua os estressores numa, hdd e chave

stress-ng --sequential 4 --class vm --exclude bigheap, brk, stack

execute 4 instâncias dos estressores de VM, um após o outro, excluindo o bigheap,
estressores brk e stack

SAIR STATUS

Status Descrição
0 Sucesso.
1 erro; opções de usuário incorretas ou um problema de recurso fatal no estresse
arnês estressor (por exemplo, sem memória).
2 Um ou mais estressores falharam.
3 Um ou mais estressores falharam na inicialização devido à falta de recursos, para
exemplo ENOMEM (sem memória) e ENOSPC (sem espaço no sistema de arquivos).

Use o stress-ng online usando os serviços onworks.net