stress-ng - En ligne dans le Cloud

PROGRAMME:

Nom

stress-ng - un outil pour charger et stresser un système informatique

SYNOPSIS

stress de [OPTION [ARG]] ...

DESCRIPTION

stress-ng testera un système informatique de diverses manières sélectionnables. Cela a été conçu
pour exercer divers sous-systèmes physiques d'un ordinateur ainsi que les divers
interfaces du noyau du système. stress-ng propose également une large gamme de tests de résistance spécifiques au processeur
qui exercent la virgule flottante, l'entier, la manipulation de bits et le flux de contrôle.

stress-ng était à l'origine destiné à faire travailler dur une machine et à déclencher des problèmes matériels
tels que les dépassements thermiques ainsi que les bogues du système d'exploitation qui ne se produisent que lorsqu'un système est
être battu durement. Utilisez stress-ng avec prudence car certains des tests peuvent faire fonctionner un système
chaud sur du matériel mal conçu et peut également provoquer un écrasement excessif du système qui peut être
difficile à arrêter.

stress-ng peut également mesurer les débits de test ; cela peut être utile d'observer
les changements de performances entre les différentes versions du système d'exploitation ou les types de matériel.
Cependant, il n'a jamais été conçu pour être utilisé comme une suite de tests de référence précise, alors ne
NE PAS l'utiliser de cette manière.

L'exécution de stress-ng avec les privilèges root ajustera les paramètres de mémoire sur les systèmes Linux
pour rendre les facteurs de stress impossibles à tuer dans les situations de faible mémoire, utilisez-le donc judicieusement. Avec
le privilège approprié, stress-ng peut permettre à la classe ionique et aux niveaux ioniques d'être
ajusté, encore une fois, cela doit être utilisé avec précaution.

On peut spécifier le nombre de processus à invoquer par type de stress test ; en spécifiant un
valeur négative ou zéro sélectionnera le nombre de processeurs disponibles tel que défini par
sysconf(_SC_NPROCESSORS_CONF).

OPTIONS

Général stress de des bactéries options:

--agressif
permet plus d'options agressives pour les fichiers, le cache et la mémoire. Cela peut ralentir les tests,
augmenter les latences et réduire le nombre d'opérations bogo ainsi que changer le
équilibre entre le temps utilisateur et le temps système utilisé en fonction du type de facteur de stress
utilisé.

-a N, --tout N
démarrer N instances de chaque facteur de stress. Si N est inférieur à zéro, alors le nombre de CPU
online est utilisé pour le nombre d'instances. Si N est zéro, alors le nombre de CPU
dans le système est utilisé.

-b N, --retrait N
attendez N microsecondes entre le début de chaque processus de travail de stress. Ceci permet
un pour accélérer les tests de résistance au fil du temps.

--classer prénom
spécifier la classe de facteurs de stress à exécuter. Les facteurs de stress sont classés en un ou plusieurs des
les classes suivantes : cpu, cpu-cache, device, io, interrupt, filesystem, memory,
réseau, système d'exploitation, tuyau, planificateur et vm. Certains facteurs de stress appartiennent à une seule classe. Pour
exemple, le facteur de stress « get » est juste dans la classe « os ». D'autres facteurs de stress entrent dans
plus d'une classe, par exemple, le facteur de stress « lsearch » tombe dans le « cpu »,
les classes 'cpu-cache' et 'memory' car il exerce tous ces trois. Sélection d'un
une classe spécifique exécutera tous les facteurs de stress qui entrent dans cette classe uniquement lors de l'exécution
avec l'option --sequential.

-n, - à sec
analysez les options, mais n'exécutez pas de tests de résistance. Un non-op.

-h, --Aidez-moi
montrer de l'aide.

--ignite-processeur
modifiez les commandes du noyau pour essayer de maximiser le processeur. Cela nécessite le privilège root pour
modifier divers / sys contrôles d'interface. Actuellement, cela ne fonctionne que pour Intel P-State
systèmes x86 activés sur Linux.

--ionice-classe classe
spécifiez la classe ionice (uniquement sous Linux). Peut être inactif (par défaut), besteffort, be,
temps réel, rt.

--ionice-niveau niveau
spécifiez le niveau d'ionice (uniquement sous Linux). Pour l'inactivité, 0 est la seule option possible. Pour
besteffort ou valeurs en temps réel de 0 (priorité la plus élevée) à 7 (priorité la plus faible). Voir
ionique(1) pour plus de détails.

-k, --keep-nom
par défaut, stress-ng tentera de changer le nom des processus de stress
selon leur fonctionnalité ; cette option le désactive et maintient le processus
names pour être le nom du processus parent, c'est-à-dire stress-ng.

--log-bref
par défaut, stress-ng rapportera le nom du programme, le type de message et le
ID de processus comme préfixe de toutes les sorties. L'option --log-brief affichera des messages
sans ces champs pour produire une sortie moins détaillée.

--fichier journal nom de fichier
écrire des messages dans le fichier journal spécifié.

--maximiser
remplace les paramètres de stress par défaut et les définit à la place au maximum
paramètres autorisés. Ces valeurs par défaut peuvent toujours être remplacées par le facteur de stress par
options de paramètres si nécessaire.

--métrique
sortie nombre d'opérations bogo au total effectuées par les processus de contrainte. Noter
qu'il ne s'agit pas d'une mesure fiable des performances ou du débit et qu'ils n'ont pas été
conçu pour être utilisé à des fins d'analyse comparative que ce soit. Les métriques ne sont qu'un moyen utile
observer le comportement d'un système lorsqu'il est soumis à divers types de charge.

Les colonnes d'informations suivantes sont affichées :

Colonne Titre Explication
bogo ops nombre d'itérations du facteur de stress pendant l'exécution.
Il s'agit d'une mesure de la quantité de « travail » global qui a été
atteint dans les opérations de bogo.
temps réel (secs) durée moyenne de l'horloge murale (en secondes) du
facteur de stress. Il s'agit de la durée totale de l'horloge murale de tous les
cas de ce facteur de stress particulier divisé par le
nombre de ces facteurs de stress en cours d'exécution.
temps usr (secs) temps utilisateur total (en secondes) consommé pour exécuter tous les
cas du facteur de stress.
sys time (secs) temps système total (en secondes) consommé pour exécuter tous les
cas du facteur de stress.
nombre total d'opérations de bogo/s (temps réel) par seconde en fonction de l'exécution de l'horloge murale
temps. L'heure de l'horloge murale reflète la course apparente
temps. Plus on a de processeurs sur un système, plus
la charge de travail peut être répartie sur ceux-ci et donc
le temps de l'horloge murale réduira et le taux d'opérations bogo
augmentera. C'est essentiellement le bogo "apparent"
taux d'opérations du système.

bogo ops/s (usr+sys time) nombre total d'opérations de bogo par seconde sur la base du cumul
temps utilisateur et système. C'est le taux réel d'opérations de bogo de
le système en tenant compte du temps réel
temps d'exécution du facteur de stress dans tous les
processeurs. En général, cela diminuera au fur et à mesure que l'on ajoute
plus de facteurs de stress simultanés en raison de conflits sur le cache,
mémoire, unités d'exécution, bus et périphériques d'E/S.

--metrics-bref
activer les métriques et uniquement les métriques de sortie non nulles.

--minimiser
remplace les paramètres de stress par défaut et les définit à la place au minimum
paramètres autorisés. Ces valeurs par défaut peuvent toujours être remplacées par le facteur de stress par
options de paramètres si nécessaire.

--pas de conseil
à partir de la version 0.02.26 stress-ng appelle automatiquement fou(2) avec avis aléatoire
options avant chaque mmap et munmap pour accentuer un peu plus le sous-système vm.
L'option --no-advise désactive cette valeur par défaut.

--page d'entrée
toucher les pages allouées qui ne sont pas dans le noyau, les forçant à être renvoyées.
est une option utile pour forcer toutes les pages allouées à être paginées lors de l'utilisation du
facteurs de stress bigheap, mmap et vm. Cela dégradera gravement les performances lorsque le
mémoire dans le système est inférieure aux tailles de tampon allouées. Cela utilise mineur(2)
pour déterminer les pages qui ne sont pas dans le noyau et doivent donc être touchées pour les paginer
de retour

--pathologique
activer les facteurs de stress connus pour bloquer les systèmes. Certains facteurs de stress peuvent rapidement
consomment des ressources de manière à pouvoir bloquer rapidement un système avant que le
noyau peut OOM les tuer. Ces facteurs de stress ne sont pas activés par défaut, cette option
les active, mais vous ne voulez probablement pas le faire. Tu étais prévenu.

--perf mesurer l'activité du processeur et du système à l'aide d'événements perf. Linux uniquement et mise en garde
videur, selon perf_event_open(2) : « Vérifiez toujours vos résultats ! Divers
les événements généralisés ont eu des valeurs erronées."

-q, --silencieux
n'affiche aucune sortie.

-r N, --Aléatoire N
démarrer N stresseurs aléatoires. Si N est 0, alors le nombre de processeurs configurés
est utilisé pour N.

--sched ordonnanceur
sélectionnez le planificateur nommé (uniquement sous Linux). Pour voir la liste des programmateurs disponibles
utiliser: stress-ng --sched qui

--sched-prio prio
sélectionnez le niveau de priorité du planificateur (uniquement sous Linux). Si le planificateur ne
le supporte, le niveau de priorité par défaut de 0 est choisi.

--séquentiel N
exécuter séquentiellement tous les facteurs de stress un par un pour une valeur par défaut de 60 secondes. Les
le nombre d'instances de chaque facteur de stress individuel à démarrer est N. Si N est inférieur
que zéro, le nombre de CPU en ligne est utilisé pour le nombre d'instances. Si
N est égal à zéro, alors le nombre de CPU du système est utilisé. Utilisez l'option --timeout
pour spécifier la durée d'exécution de chaque facteur de stress.

--syslog
sortie du journal (à l'exception des messages -v détaillés) vers le journal système.

--temp-chemin chemin
spécifier un chemin pour les répertoires temporaires stress-ng et les fichiers temporaires ; le défaut
path est le répertoire de travail courant. Ce chemin doit avoir un accès en lecture et en écriture
pour les processus de stress stress-ng.

-t N, --temps libre N
arrêter le test d'effort après N secondes. On peut aussi spécifier les unités de temps dans
secondes, minutes, heures, jours ou années avec le suffixe s, m, h, d ou y.

--timer-slack N
ajustez la marge de la minuterie par processus à N nanosecondes (Linux uniquement). Augmenter le
timer slack permet au noyau de fusionner les événements du timer en ajoutant du flou à
les délais d'expiration de la minuterie et donc de réduire les réveils. Inversement, en diminuant la minuterie
le relâchement augmentera les réveils. Une valeur de 0 pour le timer-slack réglera le système
par défaut de 50,000 XNUMX nanosecondes.

--fois
afficher les temps utilisateur et système cumulés de tous les processus enfants à la fin de
la course de stress. Le pourcentage d'utilisation du temps CPU disponible est également
calculé à partir du nombre de CPU en ligne dans le système.

--tz collecter les températures des zones thermiques disponibles sur la machine (Linux uniquement).
Certains appareils peuvent avoir une ou plusieurs zones thermiques, alors que d'autres n'en ont pas.

-dans, --verbeux
afficher tout le débogage, les avertissements et la sortie d'informations normale.

--Vérifier
vérifier les résultats lorsqu'un test est exécuté. Ceci n'est pas disponible sur tous les tests. Cette volonté
vérifier les calculs ou le contenu de la mémoire à partir d'un test et en faire rapport à
stderr tout échec inattendu.

-V, --version
afficher la version.

-X, --exclure liste
spécifiez une liste d'un ou plusieurs facteurs de stress à exclure (c'est-à-dire, ne les exécutez pas).
Ceci est utile pour exclure des facteurs de stress spécifiques lorsque l'on sélectionne de nombreux facteurs de stress à exécuter
en utilisant l'option --class, les options --sequential, --all et --random. Exemple, exécutez
les facteurs de stress de classe cpu simultanément et exclure les facteurs de stress de numa et de recherche :

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

-O, --yaml nom de fichier
sortie des statistiques rassemblées dans un fichier au format YAML nommé 'filename'.

Un stresseur groupe de neurones options:

--affinité N
démarrer N workers qui changent rapidement l'affinité du processeur (uniquement sous Linux). Commutation rapide
L'affinité CPU peut contribuer à un mauvais comportement du cache.

--opérations d'affinité N
arrêter les travailleurs d'affinité après N opérations d'affinité bogo (uniquement sous Linux).

--affinité-rand
changez l'affinité du processeur de manière aléatoire plutôt que la valeur par défaut de manière séquentielle.

--af-alg N
démarrer N travailleurs qui exercent le domaine de socket AF_ALG en hachant différentes tailles
messages aléatoires utilisant SHA1, SHA224, SHA256, SHA384, SHA512, MD4, MD5, RMD128,
Hachages RMD160, RMD256, RMD320, WP256, WP384, WP512, TGR128, TGR160 et TGR192.
(Linux uniquement).

--af-alg-ops N
arrêter les travailleurs af-alg après le hachage de N messages AF_ALG.

--aio N
démarrer N workers qui émettent plusieurs petites écritures et lectures d'E/S asynchrones sur un
fichier temporaire relativement petit utilisant l'interface POSIX aio. Cela va juste frapper
le cache du système de fichiers et absorbe beaucoup de temps d'utilisateur et de noyau dans l'émission et
gérer les demandes d'E/S. Par défaut, chaque processus de travail gérera 16
demandes d'E/S.

--aio-ops N
arrêter les travailleurs d'E/S asynchrones POSIX après N bogo requêtes d'E/S asynchrones.

--aio-requêtes N
spécifier le nombre de requêtes d'E/S asynchrones POSIX que chaque travailleur doit émettre, le
la valeur par défaut est 16 ; 1 à 4096 sont autorisés.

--aiol N
démarrer N travailleurs qui émettent plusieurs écritures d'E/S asynchrones aléatoires 4K à l'aide du
Appels système Linux aio io_setup(2), io_submit(2), io_geteventsde Géographie (2) et avec la
io_destroy(2). Par défaut, chaque processus de travail gérera 16 E/S simultanées
demandes.

--aiol-ops N
arrêter les travailleurs d'E/S asynchrones Linux après N bogo demandes d'E/S asynchrones.

--aiol-requêtes N
spécifier le nombre de requêtes d'E/S asynchrones Linux que chaque travailleur doit émettre, le
la valeur par défaut est 16 ; 1 à 4096 sont autorisés.

--apparat N
démarrez N workers qui exercent diverses parties de l'interface AppArmor. Actuellement
il faut une autorisation root pour exécuter ce test particulier. Ce test est disponible uniquement
sur les systèmes Linux avec prise en charge d'AppArmor.

--apparmor-ops
arrêter les travailleurs AppArmor après N opérations bogo.

-B N, --gros tas N
démarrer N travailleurs qui agrandissent leurs tas en réallouant de la mémoire. Si le manque de mémoire
killer (OOM) sur Linux tue le travailleur ou l'allocation échoue puis l'allocation
le processus recommence. Notez que l'ajustement du MOO pour le travailleur est défini
afin que le tueur OOM traitera ces travailleurs comme les premiers processus candidats à
tuer.

--bigheap-ops N
arrêter les travailleurs du gros tas une fois les opérations d'allocation de N bogo terminées.

--bigheap-croissance N
spécifiez la quantité de mémoire pour augmenter le tas par itération. La taille peut aller de 4K à
64 Mo. La valeur par défaut est 64K.

--bind-mount N
démarrer N travailleurs qui lient à plusieurs reprises mount / to / à l'intérieur d'un espace de noms d'utilisateur. Ceci peut
consommer des ressources rapidement, forçant des situations de mémoire. Ne pas utiliser ce
facteur de stress à moins que vous ne vouliez risquer de suspendre votre machine.

--bind-mount-ops N
arrêt après N opérations de bogo de montage de liaison.

--brk N
démarrer N travailleurs qui agrandissent le segment de données d'une page à la fois en utilisant plusieurs
brk(2) appels. Chaque nouvelle page attribuée avec succès est touchée pour s'assurer qu'elle est
résident dans la mémoire. Si une condition de mémoire insuffisante se produit, le test sera réinitialisé
le segment de données jusqu'au point avant qu'il ne démarre et répéter le segment de données
redimensionner à nouveau. Le processus ajuste le paramètre de mémoire insuffisante afin qu'il puisse
être tué par le tueur de mémoire insuffisante (OOM) avant d'autres processus. Si c'est
tué par le tueur OOM puis il sera automatiquement redémarré par une surveillance
processus parent.

--brk-ops N
arrêter les travailleurs de la brique après les opérations de la brique N bogo.

--brk-notouch
ne touchez pas à chaque page de segment de données nouvellement allouée. Cela désactive la valeur par défaut de
toucher chaque page nouvellement allouée et évite ainsi au noyau de
sauvegarder la page avec une mémoire physique réelle.

--brecherche N
démarrer N travailleurs qui recherchent binairement un tableau trié d'entiers de 32 bits en utilisant
brecherche(3). Par défaut, il y a 65536 éléments dans le tableau. C'est un utile
méthode pour exercer un accès aléatoire à la mémoire et au cache du processeur.

--bsearch-ops N
arrêter le travailleur bsearch une fois que N bogo bsearch sont terminés.

--bsearch-taille N
spécifiez la taille (nombre d'entiers de 32 bits) dans le tableau à bsearch. La taille peut être
de 1K à 4M.

-C N, --cache N
démarrer N travailleurs qui effectuent des lectures et des écritures aléatoires sur la mémoire étendue
le cache du processeur. Le code ne détermine pas intelligemment le cache CPU
configuration et il peut donc être sous-optimal pour produire des lectures/écritures aléatoires
activité pour certains processeurs.

--cache-clôture
forcer la sérialisation d'écriture sur chaque opération de stockage (x86 uniquement). Ceci est une non-opération pour
architectures non x86.

--cache-flush
forcer le vidage du cache à chaque opération de stockage (x86 uniquement). Ceci est un no-op pour les non-x86
architectures.

--niveau de cache N
spécifier le niveau de cache à exercer (1=cache L1, 2=cache L2, 3=cache L3/LLC (le
défaut)). Si la hiérarchie du cache ne peut pas être déterminée, les valeurs par défaut intégrées seront
s'appliquent.

--cache-sans-affinité
ne modifiez pas l'affinité du processeur lorsque --cache est en vigueur.

--opérations de cache N
arrêter les travailleurs de cache thrash après N bogo opérations de cache thrash.

--cache-prefetch
force la lecture anticipée à la prochaine adresse de lecture sur les architectures qui prennent en charge la lecture anticipée.

--cache-voies N
spécifiez le nombre de manières de cache à exercer. Cela permet à un sous-ensemble de l'ensemble
taille du cache à exercer.

--casquette N
démarrer N travailleurs qui lisent les capacités par processus via des appels à capget(2) (Linux
seulement).

--cap-ops N
arrêt après les opérations N cap bogo.

--chdir N
démarrer N travailleurs qui changent de répertoire entre 8192 répertoires en utilisant chdir (2).

--chdir-ops N
arrêt après les opérations N chdir bogo.

--chmod N
démarrer N travailleurs qui modifient les bits de mode de fichier via chmodde Géographie (2) et avec la fchmod(2) sur le
même fichier. Plus la valeur de N est élevée, plus il y a de conflits sur le fichier unique.
Le facteur de stress fonctionnera à travers toutes les combinaisons de bits de mode.

--chmod-ops N
arrêt après N opérations chmod bogo.

--l'horloge N
démarrer N travailleurs en train d'exercer des horloges et des minuteries POSIX. Pour tous les types d'horloge connus, cette
exercera horloge_getres(2), horloge_gettimede Géographie (2) et avec la horloge_nanosleep(2). Pour tous
temporisateurs connus, il créera un temporisateur 50000ns et un sondage occupé jusqu'à son expiration.
Ce facteur de stress entraînera de fréquents changements de contexte.

--horloge-ops N
arrêtez l'horloge des travailleurs stressés après les opérations N bogo.

--cloner N
démarrer N travailleurs qui créent des clones (via le cloner(2) appel système). Cette volonté
essayez rapidement de créer une valeur par défaut de 8192 clones qui meurent immédiatement et attendent dans un
état zombie jusqu'à ce qu'ils soient récoltés. Une fois le nombre maximum de clones atteint
(ou le clone échoue car on a atteint le maximum autorisé) le clone le plus ancien
le fil est récolté et un nouveau clone est alors créé selon le principe du premier entré, premier sorti,
puis répété. Un indicateur de clone aléatoire est sélectionné pour chaque clone afin d'essayer de
exercer différentes opérations de clonage. Le facteur de stress clone est une option Linux uniquement.

--clones-ops N
arrêter les cloneurs stresseurs après N opérations de clonage bogo.

--clone-max N
essayez de créer jusqu'à N threads clones. Ceci peut ne pas être atteint si le système
limite est inférieure à N.

--le contexte N
démarrer N travailleurs qui exécutent trois threads qui utilisent échanger le contexte(3) pour mettre en œuvre le
commutation de contexte de thread à thread. Cela exerce une sauvegarde rapide du contexte de processus et
restauration et la bande passante est limitée par les taux de sauvegarde et de restauration des registres et de la mémoire.

--context-ops N
arrêter N travailleurs de contexte après N bogo changements de contexte. Dans ce facteur de stress, 1 bogo op
équivaut à 1000 appels swapcontext.

--copier un fichier N
démarrer N facteurs de stress qui copient un fichier à l'aide de Linux copy_file_range(2) appel système.
Des morceaux de 2 Mo de données sont copiés à partir d'emplacements aléatoires d'un fichier à un autre
emplacements vers un fichier de destination. Par défaut, les fichiers ont une taille de 256 Mo. Les données sont
synchronisé avec le système de fichiers après chaque copy_file_range(2) appel.

--copy-file-ops N
s'arrêter après N appels copy_file_range().

--copie-fichier-octets N
copier la taille du fichier, la valeur par défaut est de 256 Mo. On peut spécifier la taille en unités d'octets,
KBytes, MBytes et GBytes en utilisant le suffixe b, k, m ou g.

-c N, --CPU N
démarrer N travailleurs exerçant le CPU en travaillant séquentiellement sur tous les
différentes méthodes de stress CPU. Au lieu d'exercer toutes les méthodes de stress CPU, une
peut spécifier une méthode de stress CPU spécifique avec l'option --cpu-method.

--cpu-ops N
arrêter les travailleurs du processeur de stress après les opérations N bogo.

-l P, --cpu-load P
charge le processeur avec un pourcentage de charge P pour les travailleurs de stress du processeur. 0 est effectivement un
sleep (pas de charge) et 100 est un chargement complet. La boucle de chargement est divisée en calcul
temps (charge%) et temps de sommeil (100% - charge%). La précision dépend de la charge globale de
le processeur et la réactivité du planificateur, de sorte que la charge réelle peut être
différent de la charge souhaitée. Notez que le nombre d'opérations bogo CPU peut
ne pas être mis à l'échelle linéairement avec la charge car certains systèmes utilisent la mise à l'échelle de la fréquence du processeur
et donc des charges plus lourdes produisent une fréquence CPU accrue et un bogo CPU plus important
fonctionnement sans maintenance

--cpu-load-tranche S
note - cette option n'est utile que lorsque --cpu-load est inférieur à 100%. La charge CPU
est divisé en plusieurs cycles occupés et inactifs. Utilisez cette option pour spécifier le
durée d'une tranche de temps chargée. Une valeur négative pour S spécifie le nombre de
itérations à exécuter avant de mettre le processeur au ralenti (par exemple, -30 invoque 30 itérations d'un processeur
boucle de contrainte). Une valeur zéro sélectionne un temps d'occupation aléatoire compris entre 0 et 0.5 seconde.
Une valeur positive pour S spécifie le nombre de millisecondes à exécuter avant la mise en veille
le CPU (par exemple 100 garde le CPU occupé pendant 0.1 seconde). Spécification de petites valeurs pour
S se prête à de petites tranches de temps et à une planification plus fluide. Définir --cpu-load en tant que
valeur relativement faible et --cpu-load-slice pour être grand fera cycler le CPU entre
de longs cycles d'inactivité et d'occupation et d'exercer différentes fréquences de processeur. Le thermique
la plage du processeur est également cyclée, c'est donc un bon mécanisme pour exercer le
programmateur, échelle de fréquence et mécanismes de refroidissement thermique passif/actif.

--méthode-cpu méthode
spécifier une méthode de contrainte du processeur. Par défaut, toutes les méthodes de stress sont exercées
séquentiellement, cependant on peut spécifier une seule méthode à utiliser si nécessaire.
Les méthodes de stress CPU disponibles sont décrites comme suit :

Méthode Description
tous itérer sur toutes les méthodes de stress cpu ci-dessous
ackermann Fonction d'Ackermann : calculer A(3, 10), où :
A(m, n) = n + 1 si m = 0 ;
A(m - 1, 1) si m > 0 et n = 0 ;
A(m - 1, A(m, n - 1)) si m > 0 et n > 0
bitops diverses opérations binaires de bithack, à savoir : bits inversés, parité
vérifier, nombre de bits, arrondir à la puissance de 2 la plus proche
callfunc appelle récursivement la fonction C à 8 arguments jusqu'à une profondeur de 1024 appels
et détendez-vous
cfloat 1000 itérations d'un mélange d'opérations complexes en virgule flottante
cdouble 1000 itérations d'un mélange de double complexe à virgule flottante

clongdouble 1000 itérations d'un mélange de long double complexe à virgule flottante

corréler effectuer une corrélation de 16384 × 1024 de doubles aléatoires
crc16 calcule 1024 tours de CCITT CRC16 sur des données aléatoires
decimal32 1000 itérations d'un mélange de virgule flottante décimale 32 bits
opérations (GCC uniquement)
decimal64 1000 itérations d'un mélange de virgule flottante décimale 64 bits
opérations (GCC uniquement)
decimal128 1000 itérations d'un mélange de virgule flottante décimale 128 bits
opérations (GCC uniquement)
tramage Floyd–Steinberg tramage d'une image aléatoire 1024 × 768 à partir de 8 bits
jusqu'à 1 bit de profondeur.
djb2a 128 tours de hachage DJB2a (hachage Dan Bernstein utilisant le xor
variante) sur 128 à 1 octets de chaînes aléatoires
double 1000 itérations d'un mélange de virgule flottante double précision

Euler calcule e en utilisant n = (1 + (1 ÷ n)) ↑ n
explog itérer sur n = exp(log(n) 1.00002)
fibonacci calcule la séquence de Fibonacci de 0, 1, 1, 2, 5, 8...
fft 4096 échantillon Transformée de Fourier rapide
float 1000 itérations d'un mélange d'opérations en virgule flottante
fnv1a 128 tours de hachage FNV-1a (hachage Fowler-Noll-Vo utilisant le xor puis
multiplier la variante) sur 128 à 1 octets de chaînes aléatoires
gamma calculer la constante d'Euler-Mascheroni en utilisant la limite
différence entre les séries harmoniques (1 + 1/2 + 1/3 + 1/4 + 1/5
... + 1/n) et le logarithme népérien ln(n), pour n = 80000.
gcd calcule le PGCD des entiers
gray calculer le code binaire en code gray et le code gray de nouveau en binaire pour
entiers de 0 à 65535
hamming calcule les codes Hamming H(8,4) sur 262144 lots de données 4 bits. Cette
transforme les données de 4 bits en code de Hamming de 8 bits contenant 4 bits de parité.
Pour les bits de données d1..d4, les bits de parité sont calculés comme :
p1 = d2 + d3 + d4
p2 = d1 + d3 + d4
p3 = d1 + d2 + d4
p4 = d1 + d2 + d3
hanoi résout une pile de 21 disques de tours de Hanoï en utilisant la solution récursive
calcul hyperbolique sinh(θ) × cosh(θ) + sinh(2θ) + cosh(3θ) pour float, double
et les fonctions sinus et cosinus hyperboliques doubles longues où θ = 0
à 2π en 1500 pas
idct 8 × 8 IDCT (Transformée en cosinus discrète inverse)
int8 1000 itérations d'un mélange d'opérations entières de 8 bits
int16 1000 itérations d'un mélange d'opérations entières de 16 bits
int32 1000 itérations d'un mélange d'opérations entières de 32 bits
int64 1000 itérations d'un mélange d'opérations entières de 64 bits

int128 1000 itérations d'un mélange d'opérations entières de 128 bits (GCC uniquement)
int32float 1000 itérations d'un mélange d'entier 32 bits et de virgule flottante

int32double 1000 itérations d'un mélange d'entier 32 bits et de double précision
opérations en virgule flottante
int32longdouble 1000 itérations d'un mélange d'entier 32 bits et de long double
opérations de précision en virgule flottante
int64float 1000 itérations d'un mélange d'entier 64 bits et de virgule flottante

int64double 1000 itérations d'un mélange d'entier 64 bits et de double précision
opérations en virgule flottante
int64longdouble 1000 itérations d'un mélange d'entier 64 bits et de long double
opérations de précision en virgule flottante
int128float 1000 itérations d'un mélange d'entier 128 bits et de virgule flottante
opérations (GCC uniquement)
int128double 1000 itérations d'un mélange d'entier 128 bits et de double précision
opérations en virgule flottante (GCC uniquement)
int128longdouble 1000 itérations d'un mélange d'entier 128 bits et de long double
opérations de précision en virgule flottante (GCC uniquement)
int128decimal32 1000 itérations d'un mélange d'entier 128 bits et décimal 32 bits
opérations en virgule flottante (GCC uniquement)
int128decimal64 1000 itérations d'un mélange d'entier 128 bits et décimal 64 bits
opérations en virgule flottante (GCC uniquement)
int128decimal128 1000 itérations d'un mélange d'entier 128 bits et décimal 128 bits
opérations en virgule flottante (GCC uniquement)
jenkin Le hachage entier de Jenkin sur 128 tours de 128..1 octets de données aléatoires
jmp Comparaison simple non optimisée >, <, == et branchement jmp
calcul ln2 ln(2) basé sur des séries :
1 - 1/2 + 1/3 - 1/4 + 1/5 - 1/6 ...
longdouble 1000 itérations d'un mélange de virgule flottante longue double précision

boucle simple boucle vide
matriceprod produit matriciel de deux matrices 128 × 128 de doubles flottants. Essai
sur du matériel 64 bits x86 montre que cela fournit un bon mélange de
opérations de mémoire, de cache et de virgule flottante et est probablement le
meilleure méthode CPU à utiliser pour faire fonctionner un CPU à chaud.
nsqrt calcule sqrt() de longs doubles à l'aide de Newton-Raphson
omega calcule la constante oméga définie par Ωe↑Ω = 1 en utilisant
itération de Ωn+1 = (1 + Ωn) / (1 + e↑Ωn)
parité calculer la parité à l'aide de diverses méthodes de Standford Bit
Twiddling Hacks. Les méthodes employées sont : la manière naïve, la méthode naïve
manière avec l'optimisation du comptage de bits de Brian Kernigan, le
manière multipliée, la manière parallèle, et les manières de table de recherche (2
variantes).
phi calcule le nombre d'or en utilisant des séries
pi calcule π en utilisant l'algorithme de convergence rapide de Srinivasa Ramanujan
pjw 128 tours de hachage fonction pjw sur 128 à 1 octets aléatoires
instruments à cordes
prime trouver tous les nombres premiers dans la plage 1..1000000 en utilisant un peu
recherche de division d'essai naïve par force brute optimisée
psi calcule (la constante de Fibonacci réciproque) en utilisant la somme des
réciproques des nombres de Fibonacci
les reines calculent toutes les solutions du problème classique des 8 reines pour
tailles de planche 1..12
rand 16384 itérations de rand(), où rand est le pseudo-aléatoire MWC
générateur de nombres. La fonction aléatoire MWC concatène deux 16 bits
Générateurs de multiplication avec report :
x(n) = 36969 × x(n - 1) + retenue,
y(n) = 18000 × y(n - 1) + carry mod 2 16

et a une période d'environ 2 ↑ 60
rand48 16384 itérations de drand48de Géographie (3) et avec la lrand48(3)
rgb convertit RVB en YUV et de nouveau en RVB (CCIR 601)
sdbm 128 tours de hachage sdbm (tel qu'utilisé dans la base de données SDBM et GNU awk)
sur 128 à 1 octets de chaînes aléatoires
tamis trouver les nombres premiers dans la plage 1..10000000 en utilisant le tamis de
Eratosthenes
sqrt calcule sqrt(rand()), où rand est le nombre pseudo-aléatoire MWC
générateur

trig calcule sin(θ) × cos(θ) + sin(2θ) + cos(3θ) pour float, double et
fonctions longues double sinus et cosinus où θ = 0 à 2π en 1500
mesures
union effectue une arithmétique d'entiers sur un mélange de champs de bits dans une union C.
Cela montre à quel point le compilateur et le processeur peuvent exécuter des entiers
charge et stocke les champs de bits.
zeta calcule la fonction Riemann Zeta (s) pour s = 2.0...10.0

Notez que certaines de ces méthodes essaient d'exercer le CPU avec des calculs trouvés dans
certains cas d'utilisation du monde réel. Cependant, le code n'a pas été optimisé sur un
base de l'architecture, il peut donc s'agir d'un sous-optimal par rapport au code optimisé à la main utilisé dans
certaines candidatures. Ils essaient de représenter les mélanges d'instructions typiques trouvés dans
ces cas d'utilisation.

--cpu-en ligne N
démarrer N workers qui mettent hors ligne et en ligne des processeurs sélectionnés au hasard. Ce Linux uniquement
stressor nécessite le privilège root pour effectuer cette action.

--cpu-opérations-en-ligne N
s'arrêter après les opérations hors ligne/en ligne.

--crypte N
démarrer N travailleurs qui chiffrent un mot de passe aléatoire de 16 caractères en utilisant crypte(3). le
le mot de passe est crypté à l'aide des méthodes de cryptage MD5, SHA-256 et SHA-512.

--crypt-ops N
arrêt après N opérations de chiffrement bogo.

--démon N
démarrer N travailleurs qui créent chacun un démon qui meurt immédiatement après la création
un autre démon et ainsi de suite. Cela fonctionne efficacement à travers la table de processus avec
processus de courte durée qui n'ont pas de parent et sont attendus par init. Cette
met la pression sur init pour faire une récolte rapide des enfants. Les processus démons effectuent les
mélange habituel d'appels pour se transformer en démons UNIX typiques, donc cela imite artificiellement
stress très important du système démon.

--démon-ops N
arrêter les travailleurs du démon après la création de N démons.

-D N, --dentaire N
démarrer N travailleurs qui créent et suppriment des entrées de répertoire. Cela devrait créer un fichier
activité des métadonnées du système. Les noms des entrées du répertoire sont suffixés par un code gray
numéro encodé pour essayer de mélanger le hachage de l'espace de noms.

--opérations dentaires N
arrêter les travailleurs de denty thrash après les opérations de dentry N bogo.

--dentry-ordre [ | inverser | foulée | aléatoire ]
spécifier l'ordre de dissociation des dentries, peut être l'un des avant, arrière, foulée ou aléatoire.
Par défaut, les dentries sont dissociées dans un ordre aléatoire. L'ordre à terme sera dissocié
les du premier au dernier, l'ordre inverse les déliera du dernier au premier, foulée
l'ordre les dissociera en contournant l'ordre de manière quasi-aléatoire et
ordre aléatoire sélectionnera au hasard l'un des ordres avant, arrière ou foulée.

--dentaires N
créer N dentries par dentry thrashing boucle, la valeur par défaut est 2048.

--rép N
démarrez N travailleurs qui créent et suppriment des répertoires à l'aide de mkdir et rmdir.

--répertoires N
arrêter les travailleurs de thrash de répertoire après N opérations de répertoire bogo.

--dup N
démarrer N travailleurs qui effectuent dup(2) puis close(2) opérations sur /dev/zero. Les
le nombre maximal d'ouvertures à la fois est défini par le système, le test se déroulera donc jusqu'à ce
maximum, ou 65536 descripteurs de fichiers ouverts, selon la première occurrence.

--dup-ops N
arrêter les travailleurs de stress dup après les opérations ouvertes N bogo.

--epoll N
démarrer N travailleurs qui effectuent diverses activités liées au stress de l'emboîture en utilisant
epoll_wait(2) pour surveiller et gérer les nouvelles connexions. Cela implique client/serveur
processus effectuant des connexions, des envois/réceptions et des déconnexions rapides en local
hôte. L'utilisation d'epoll permet de gérer efficacement un grand nombre de connexions,
cependant, cela peut entraîner un remplissage et un blocage supplémentaires de la table de connexion
connexions socket, ce qui a un impact sur les statistiques d'opération epoll bogo. Pour ipv4 et ipv6
domaines, plusieurs serveurs sont générés sur plusieurs ports. Le facteur de stress epoll est pour
Linux uniquement.

--epoll-domaine D
spécifiez le domaine à utiliser, la valeur par défaut est unix (aka local). Actuellement ipv4, ipv6
et unix sont pris en charge.

--epoll-port P
démarrer au port de socket P. Pour les processus de travail N epoll, les ports P à (P * 4) - 1 sont
utilisé pour ipv4, les domaines ipv6 et les ports P à P - 1 sont utilisés pour le domaine unix.

--epoll-ops N
arrêter les travailleurs d'epoll après les opérations de N bogo.

--événementfd N
démarrer N processus de travail parent et enfant qui lisent et écrivent des messages d'événement de 8 octets
entre eux via le mécanisme eventfd (Linux uniquement).

--eventfd-ops N
arrêter les travailleurs eventfd après N opérations bogo.

--exec N
démarrer N travailleurs en forçant continuellement les enfants qui exécutent le stress, puis sortir
presque immédiatement.

--exec-ops N
arrêter les travailleurs de stress exécutif après les opérations N bogo.

--exec-max P
créer P processus enfants qui exécutent stress-ng, puis attendre qu'ils se terminent par
itération. La valeur par défaut est juste 1 ; des valeurs plus élevées créeront de nombreux zombies temporaires
processus qui attendent d'être récoltés. On peut potentiellement remplir le processus
table utilisant des valeurs élevées pour --exec-max et --exec.

-F N, --fallocate N
démarrer N travailleurs en cascade (pré-allocation d'espace fichier) et en synchronisation
(troncature de fichier) fichiers temporaires. Si le fichier est plus volumineux que l'espace libre,
fallocate produira une erreur ENOSPC qui est ignorée par ce facteur de stress.

--fallocate-octets N
taille de fichier allouée, la valeur par défaut est 1 Go. On peut spécifier la taille en unités de
Octets, Ko, Mo et Go en utilisant le suffixe b, k, m ou g.

--fallocate-opérations N
arrêter les travailleurs de stress de fallocate après les opérations de fallocate de N bogo.

--la faute N
démarrer N travailleurs qui génèrent des défauts de page mineurs et majeurs.

--opérations de panne N
arrêter les travailleurs de défaut de page après N bogo opérations de défaut de page.

--fcntl N
démarrer N travailleurs qui effectuent fctl(2) appels avec diverses commandes. L'exercé
les commandes (si disponibles) sont : 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 et F_SETSIG.

--fcntl-ops N
arrêter les travailleurs fcntl après N bogo fcntl opérations.

--fiemap N
démarrer N travailleurs qui créent chacun un fichier avec de nombreuses extensions changeant de manière aléatoire et ont
4 processus enfants par travailleur qui collectent les informations d'étendue à l'aide du
FS_IOC_FIEMAP ioctl (2).

--fiemap-ops N
arrêt après N opérations fiemap bogo.

--fiemap-taille N
spécifiez la taille du fichier fiemap'd en octets. On peut spécifier la taille en unités
d'octets, Ko, Mo et Go en utilisant le suffixe b, k, m ou g. Fichiers plus volumineux
contiendra plus d'étendues, provoquant plus de stress lors de la collecte d'informations sur l'étendue.

--fifo N
démarrer N workers qui exercent un canal nommé en transmettant des entiers de 64 bits.

--fifo-ops N
arrêter les travailleurs fifo après les opérations d'écriture du tube N bogo.

--fifo-lecteurs N
pour chaque travailleur, créez N travailleurs de lecteur fifo qui lisent le tube nommé à l'aide de simples
blocage des lectures.

--nom de fichier N
démarrer N travailleurs qui exercent la création de fichiers en utilisant des noms de fichiers de différentes longueurs
contenant une plage de caractères de nom de fichier d'autorisation. Cela va essayer de voir si cela peut
dépasser la longueur de nom de fichier autorisée par le système de fichiers était bien de tester divers noms de fichiers
longueurs comprises entre 1 et le maximum autorisé par le système de fichiers.

--filename-ops N
arrêter les travailleurs de nom de fichier après N bogo tests de nom de fichier.

--filename-opts opter
utiliser des caractères dans le nom de fichier en fonction de l'option 'opt'. Les options valides sont :

Option Description
option de sonde par défaut, sonde le système de fichiers pour les caractères autorisés valides
dans un nom de fichier et utilisez-les
posix utilise des caractères comme spécifié par les spécifications de base du groupe ouvert
Édition 7, POSIX.1-2008, 3.278 Jeu de caractères de nom de fichier portable
ext utilise les caractères autorisés par les systèmes de fichiers ext2, ext3, ext4,
à savoir tout caractère 8 bits en dehors de NUL et /

--troupeau N
démarrer N travailleurs verrouillant sur un seul fichier.

--flock-ops N
arrêter les travailleurs du stress du troupeau après les opérations du troupeau N bogo.

-f N, --fourchette N
commencer N travailleurs forçant continuellement les enfants qui sortent immédiatement.

--fork-ops N
arrêtez les travailleurs stressés par la fourche après les opérations de N bogo.

--fork-max P
créer P processus enfants, puis attendre qu'ils se terminent par itération. Le défaut
est juste 1 ; des valeurs plus élevées créeront de nombreux processus zombies temporaires qui sont
en attendant d'être récolté. On peut potentiellement remplir la table de processus en utilisant une haute
valeurs pour --fork-max et --fork.

--fp-erreur N
démarrer N workers qui génèrent des exceptions à virgule flottante. Les calculs sont effectués
pour forcer et vérifier les FE_DIVBYZERO, FE_INEXACT, FE_INVALID, FE_OVERFLOW et
Exceptions FE_UNDERFLOW. Les erreurs EDOM et ERANGE sont également vérifiées.

--fp-erreur-ops N
arrêt après N bogo exceptions à virgule flottante.

--fstat N
démarrer N workers fstat'ing fichiers dans un répertoire (la valeur par défaut est / dev).

--fstat-opérations N
arrêter les travailleurs stressés de fstat après les opérations de N bogo fstat.

--fstat-rép annuaire
spécifiez le répertoire à fstat pour remplacer la valeur par défaut de /dev. Tous les fichiers dans
le répertoire sera fstat'd à plusieurs reprises.

--futex N
démarrer N travailleurs qui exécutent rapidement l'appel système futex. Chaque travailleur a deux
processus, un serveur futex et un réveil futex. Le serveur attend avec un tout petit
timeout pour souligner le délai d'attente et l'attente rapide du futex à interrogation. C'est un Linux
option de stress spécifique.

--futex-ops N
arrêter les travailleurs futex après N bogo opérations d'attente futex réussies.

--obtenir N
démarrer N travailleurs qui appellent tous les appels système get*(2).

--get-ops N
arrêter d'obtenir des travailleurs après N bogo obtenir des opérations.

--getdent N
démarrer N travailleurs qui lisent les répertoires de manière récursive / proc, / dev /, / Tmp, / sys et / courir
en utilisant getdents et getdents64 (Linux uniquement).

--getdent-ops N
arrêter les travailleurs getdent après les opérations N bogo getdent bogo.

--getrandom N
démarrer N travailleurs qui obtiennent 8192 octets aléatoires du pool /dev/urandom en utilisant le
obtenir au hasard(2) appel système (Linux uniquement).

--getrandom-ops N
arrêter les travailleurs getrandom après les opérations N bogo get.

--manipuler N
démarrer N travailleurs qui exercent le nom_à_handle_atde Géographie (2) et avec la open_by_handle_at(2)
appels système. (Linux uniquement).

--handle-ops N
s'arrêter après N gérer les opérations bogo.

-d N, --HDD N
démarrer N travailleurs écrivant, lisant et supprimant continuellement les fichiers temporaires.

--hdd-octets N
écrire N octets pour chaque processus hdd, la valeur par défaut est 1 Go. On peut spécifier la taille
en unités d'octets, Koctets, MBytes et GBytes en utilisant le suffixe b, k, m ou g.

--hdd-opt liste
spécifiez diverses options de test de résistance sous forme de liste séparée par des virgules. Les options sont comme
suit:

Option Description
essayez directement de minimiser les effets de cache des E/S. Les écritures d'E/S de fichier sont
effectué directement à partir des tampons de l'espace utilisateur et synchrone
le transfert est également tenté. Pour garantir des E/S synchrones, également
utilisez l'option de synchronisation.
dsync s'assure que la sortie a été transférée vers le matériel et le fichier sous-jacents
les métadonnées ont été mises à jour (à l'aide de l'indicateur d'ouverture O_DSYNC). C'est
équivalent à chacun écrire(2) suivi d'un appel à
fdatasync(2). Voir aussi l'option fdatasync.
fadv-dontneed conseille au noyau de s'attendre à ce que les données ne soient pas accessibles dans un proche
avenir.
fadv-noreuse conseille au noyau de s'attendre à ce que les données ne soient accessibles qu'une seule fois.
fadv-normal conseille au noyau qu'il n'y a pas de modèle d'accès explicite pour les données.
Il s'agit de l'hypothèse de conseil par défaut.
fadv-rnd conseille au noyau de s'attendre à des modèles d'accès aléatoire pour les données.
fadv-seq conseille au noyau de s'attendre à des modèles d'accès séquentiels pour les données.
fadv-willneed conseille au noyau de s'attendre à ce que les données soient accessibles dans un proche
avenir.

fsync vide toutes les données in-core modifiées après chaque écriture sur la sortie
appareil utilisant un fsync(2) appel.
fdatasync similaire à fsync, mais ne videz pas les métadonnées modifiées à moins que
les métadonnées sont nécessaires pour que les lectures de données ultérieures soient gérées correctement.
Cela utilise un explicite fdatasync(2) appel.
iovec utilise plusieurs E/S de mémoire tampon readv/writev plutôt que read/write.
Au lieu d'une opération de lecture/écriture, le tampon est divisé en un
iovec de 16 tampons.
noatime ne met pas à jour l'horodatage du dernier accès au fichier, cela peut réduire
écritures de métadonnées.
sync s'assure que la sortie a été transférée vers le matériel sous-jacent (à l'aide
le drapeau ouvert O_SYNC). Cela équivaut à un chacun écrire(2) étant
suivi d'un appel à fsync(2). Voir aussi l'option fsync.
rd-rnd lit les données au hasard. Par défaut, les données écrites ne sont pas relues,
cependant, cette option forcera sa relecture aléatoire.
rd-seq lit les données de manière séquentielle. Par défaut, les données écrites ne sont pas relues,
cependant, cette option forcera sa relecture séquentielle.
syncfs écrivent toutes les modifications mises en mémoire tampon des métadonnées et des données du fichier sur le
système de fichiers qui contient les fichiers de travail du disque dur.
utimes force la mise à jour de l'horodatage du fichier, ce qui peut augmenter les écritures de métadonnées.
wr-rnd écrit les données de manière aléatoire. L'option wr-seq ne peut pas être utilisée en même temps
le temps.
wr-seq écrit les données de manière séquentielle. C'est la valeur par défaut si aucun mode d'écriture n'est
spécifié.

Notez que certaines de ces options sont mutuellement exclusives, par exemple, il ne peut y avoir qu'une seule
méthode d'écriture ou de lecture. De plus, les indicateurs fadvise peuvent être mutuellement exclusifs, par exemple
fadv-willneed ne peut pas être utilisé avec fadv-dontneed.

--hdd-ops N
arrêter les travailleurs de stress hdd après les opérations N bogo.

--hdd-write-size N
spécifier la taille de chaque écriture en octets. La taille peut aller de 1 octet à 4 Mo.

--tri en tas N
démarrez N travailleurs qui trient les entiers 32 bits à l'aide du tri de tas BSD.

--opérations de tri en tas N
arrêtez les travailleurs de stress des tris en tas après N bogo tris en tas.

--heapsort-size N
spécifiez le nombre d'entiers de 32 bits à trier, la valeur par défaut est 262144 (256 × 1024).

--hrecherche N
démarrer N travailleurs qui recherchent une table de hachage complète à 80 % en utilisant hrecherche(3). Par défaut,
il y a 8192 éléments insérés dans la table de hachage. C'est une méthode utile pour
exercer l'accès à la mémoire et au cache du processeur.

--hsearch-ops N
arrêter les travailleurs hsearch une fois que N bogo hsearch opérations sont terminées.

--hsearch-taille N
spécifiez le nombre d'entrées de hachage à insérer dans la table de hachage. La taille peut être
de 1K à 4M.

--icache N
démarrer N travailleurs qui stressent le cache d'instructions en forçant le cache d'instructions
recharges. Ceci est réalisé en modifiant une ligne de cache d'instructions, provoquant le
processeur pour le recharger lorsque nous appelons une fonction à l'intérieur. Actuellement seulement
vérifié et activé pour les processeurs Intel x86.

--icache-ops N
arrêter les travailleurs de l'icache une fois les opérations N bogo icache terminées.

--inotifier N
démarrer N travailleurs effectuant des activités de système de fichiers telles que la création/suppression
fichiers/répertoires, déplacement de fichiers, etc.
(Linux uniquement).

--inotify-ops N
arrêter d'informer les travailleurs stressés après les opérations de N innotifier bogo.

-i N, --io N
démarrer N travailleurs appelant en permanence synchroniser(2) pour valider le cache tampon sur le disque. Cette
peut être utilisé avec les options --hdd.

--io-ops N
stop io stress les travailleurs après les opérations de N bogo.

--timer N
démarrer N travailleurs qui utilisent les minuteurs d'intervalle du système. Cela met en place un
Timer ITIMER_PROF qui génère un signal SIGPROF. La fréquence par défaut du
itimer est de 1 MHz, cependant, le noyau Linux le réglera pour qu'il ne soit pas plus que le
réglage rapide, par conséquent les signaux SIGPROF haute fréquence ne sont normalement pas possibles. UNE
la boucle occupée tourne gettimer(2) appels pour consommer du CPU et donc décrémenter le timer
en fonction du temps passé en temps CPU et système.

--timer-ops N
arrêter les travailleurs de stress itimer après N bogo itimer signaux SIGPROF.

--timer-freq F
exécuter le temporisateur à F Hz; plage de 1 à 1000000 Hz. Normalement, la fréquence la plus élevée est
limité par le nombre de jiffy ticks par seconde, donc courir au-dessus de 1000 Hz est
difficile à atteindre en pratique.

--kcmp N
démarrer N travailleurs qui utilisent kcmp(2) comparer les processus parent et enfant pour déterminer
s'ils partagent les ressources du noyau (Linux uniquement).

--kcmp-ops N
arrêter les travailleurs kcmp après les opérations N bogo kcmp.

--clé N
démarrer N travailleurs qui créent et manipulent des clés à l'aide clé_ajoutde Géographie (2) et avec la ketctl(2). Comme
de nombreuses clés sont créées selon la limite par utilisateur, puis le keyctl suivant
des commandes sont exercées sur chaque touche : KEYCTL_SET_TIMEOUT, KEYCTL_DESCRIBE,
KEYCTL_UPDATE, KEYCTL_READ, KEYCTL_CLEAR et KEYCTL_INVALIDATE.

--key-ops N
arrêter les travailleurs clés après N opérations clés bogo.

--tuer N
démarrer N travailleurs envoyant des signaux d'arrêt SIGUSR1 à un gestionnaire de signaux SIG_IGN. La plupart de
le temps de traitement se terminera dans l'espace du noyau.

--kill-ops N
arrêter de tuer les travailleurs après les opérations de N bogo kill.

--klog N
démarrer N travailleurs exerçant le noyau syslog(2) appel système. Cela tentera de
lire le journal du noyau avec des tampons de lecture de différentes tailles. Linux uniquement.

--klog-ops N
arrêter les travailleurs de klog après N opérations syslog.

--bail N
démarrer N travailleurs verrouillant, déverrouillant et rompant les baux via le fctl(2) F_SETLEASE
opération. Les processus parent verrouillent et déverrouillent continuellement un bail sur un fichier tout en
un nombre de processus enfants sélectionnable par l'utilisateur ouvre le fichier avec une ouverture non bloquante
pour générer des notifications de rupture de bail SIGIO au parent. Ce facteur de stress est
disponible uniquement si la prise en charge de F_SETLEASE, F_WRLCK et F_UNLCK est fournie par fctl (2).

--opérations de location N
arrêter les travailleurs de location après les opérations de N bogo.

--rupteurs de bail N
démarrer N processus enfants de rupture de bail par travailleur de bail. Normalement, un enfant est
beaucoup pour forcer de nombreux signaux de notification de rupture de bail SIGIO au parent,
cependant, cette option permet de spécifier plus de processus enfants si nécessaire.

--relier N
démarrer N travailleurs créant et supprimant des liens physiques.

--link-ops N
arrêtez les travailleurs de stress de lien après les opérations de N bogo.

--lockbus N
démarrer N travailleurs qui verrouillent et incrémentent rapidement 64 octets de mémoire choisie au hasard
à partir d'une région mmap'd de 16 Mo (processeurs Intel x86 uniquement). Cela provoquera des échecs de cacheline
et le blocage des processeurs.

--lockbus-ops N
arrêter les travailleurs des éclusiers après les opérations de N bogo.

--lockf N
démarrer N travailleurs qui verrouillent et déverrouillent de manière aléatoire des régions d'un fichier à l'aide de POSIX
verrou(3) mécanisme de verrouillage. Chaque travailleur crée un fichier de 64 Ko et tente de conserver un
maximum de 1024 verrous simultanés avec un processus enfant qui essaie également d'en conserver 1024
verrouillages simultanés. Les anciennes serrures sont déverrouillées selon le principe du premier entré, premier sorti.

--lockf-ops N
arrêter les travailleurs lockf après N opérations de lockf bogo.

--lockf-nonblock
au lieu d'utiliser le blocage F_LOCK verrou(3) commandes, utilisez F_TLOCK non bloquant
commandes et réessayez si le verrouillage a échoué. Cela crée une surcharge d'appel système supplémentaire
et l'utilisation du processeur à mesure que le nombre de travailleurs lockf augmente et devrait augmenter
conflit de verrouillage.

--longjmp N
démarrer N travailleurs qui font de l'exercice setjmp(3) /longjmp(3) par bouclage rapide sur longjmp
appels.

--longjmp-ops N
arrêter les travailleurs de stress longjmp après N opérations bogo longjmp (1 bogo op vaut 1000
appels longjmp).

--lsearch N
démarrer N travailleurs qui recherchent linéairement un tableau non trié d'entiers 32 bits à l'aide
lrecherche(3). Par défaut, il y a 8192 éléments dans le tableau. C'est un utile
méthode pour exercer un accès séquentiel à la mémoire et au cache du processeur.

--lsearch-ops N
arrêter les travailleurs lsearch une fois que N bogo lsearch opérations sont terminées.

--lsearch-taille N
spécifiez la taille (nombre d'entiers de 32 bits) dans le tableau à lsearch. La taille peut être
de 1K à 4M.

--malloc N
démarrer N travailleurs appelant en permanence malloc(3), callo(3), réallouerde Géographie (3) et avec la gratuitement (3).
Par défaut, jusqu'à 65536 allocations peuvent être actives à tout moment, mais cela peut être
modifié avec l'option --malloc-max. L'allocation, la réallocation et la libération sont
choisi au hasard; 50% du temps mémoire est alloué (via malloc, calloc ou
realloc) et 50 % du temps alloué est libéré. Les tailles d'allocation sont également
aléatoire, avec la taille d'allocation maximale contrôlée par l'option --malloc-bytes,
la taille par défaut étant 64K. Le travailleur est redémarré s'il est tué par le
tueur de mémoire (OOM).

--malloc-octets N
maximum par taille d'allocation/réallocation. Les allocations sont choisies au hasard parmi 1
à N octets. On peut spécifier la taille en unités de Bytes, KBytes, MBytes et GBytes
en utilisant le suffixe b, k, m ou g. Les grandes tailles d'allocation provoquent l'allocateur de mémoire
à utiliser mmap(2) plutôt que d'étendre le tas en utilisant brk (2).

--malloc-max N
nombre maximal d'allocations actives autorisées. Les allocations sont choisies au hasard et
placé dans un créneau d'allocation. Parce qu'environ 50%/50% répartis entre l'allocation et
libération, généralement la moitié des créneaux d'allocation sont utilisés à un moment donné.

--malloc-ops N
arrêt après les opérations de N malloc bogo. Une opération bogo se rapporte à une réussite
malloc(3), callo(3) ou réallouer (3).

--malloc-seuil N
spécifier le seuil où malloc utilise mmap(2) au lieu de sbrk(2) pour allouer plus
Mémoire. Ceci n'est disponible que sur les systèmes qui fournissent le GNU C mallette(3) réglage
la fonction.

--matrice N
démarrer N travailleurs qui effectuent diverses opérations matricielles sur des valeurs à virgule flottante. Par
par défaut, cela exercera toutes les méthodes de contrainte matricielle une par une. On peut
spécifiez une méthode de contrainte matricielle spécifique avec l'option --matrix-method.

--matrice-ops N
arrêter les travailleurs de stress matriciel après N opérations bogo.

--méthode-matrice méthode
spécifier une méthode de contrainte matricielle. Les méthodes de contrainte matricielle disponibles sont décrites comme
suit:

Méthode Description
tous itérer sur toutes les méthodes de contrainte matricielle ci-dessous
ajouter ajouter deux matrices N × N
copier copier une matrice N × N dans une autre
div divise une matrice N × N par un scalaire
hadamard Hadamard produit de deux matrices N × N
frobenius produit de Frobenius de deux matrices N × N
moyenne arithmétique moyenne de deux matrices N × N
multiplier une matrice N × N par un scalaire
prod produit de deux matrices N × N
soustraire une matrice N × N d'une autre matrice N × N
trans transposer une matrice N × N

--matrice-taille N
spécifier la taille N × N des matrices. Des valeurs plus petites donnent une virgule flottante
calculer le facteur de stress lié au débit, où des valeurs élevées entraînent un cache et/ou
facteur de stress lié à la bande passante de la mémoire.

--membre N
démarrer N travailleurs qui exécutent l'appel système membarrier (Linux uniquement).

--membre-ops N
arrêter les travailleurs de stress membarrier après les opérations de N bogo membarrier.

--memcpy N
démarrer N workers qui copient 2 Mo de données d'une région partagée vers un tampon à l'aide
mémcpy(3) puis déplacez les données dans le tampon avec mémoriser(3) avec 3 différents
alignements. Cela sollicitera le cache du processeur et la mémoire système.

--memcpy-ops N
arrêtez les travailleurs stressés de memcpy après les opérations de N bogo memcpy.

--memfd N
démarrer N travailleurs qui créent 256 allocations de 1024 XNUMX pages à l'aide de memfd_createde Géographie (2) et avec la
tronquer(2) pour l'attribution et mmap(2) pour mapper l'allocation dans le processus
espace d'adressage. (Linux uniquement).

--memfd-ops N
arrêt après N memfd-créer(2) opérations bogo.

--tri par fusion N
démarrez N travailleurs qui trient les entiers 32 bits à l'aide du mergesort BSD.

--mergesort-ops N
arrêter les travailleurs de stress mergesort après N bogo mergesorts.

--mergesort-taille N
spécifiez le nombre d'entiers de 32 bits à trier, la valeur par défaut est 262144 (256 × 1024).

--mincore N
démarrer N travailleurs qui parcourent toute la mémoire 1 page à la fois en vérifiant le
page mappée et réside également en mémoire à l'aide mineur (2).

--mincore-ops N
arrêt après N opérations mineures de bogo. Un mincore bogo op équivaut à 1000
mineur(2) appels.

--mincore-aléatoire
au lieu de parcourir les pages de manière séquentielle, sélectionnez les pages au hasard. L'élu
l'adresse est itérée en la décalant à droite d'un endroit et vérifiée par mincore
jusqu'à ce que l'adresse soit inférieure ou égale à la taille de la page.

--mknod N
démarrer N travailleurs qui créent et suppriment des fifos, des fichiers vides et des sockets nommés en utilisant
mknod et dissociez.

--mknod-ops N
arrêter les travailleurs de thrash de répertoire après N opérations bogo mknod.

--mlock N
démarrer N travailleurs qui verrouillent et déverrouillent les pages mappées en mémoire à l'aide mlock(2),
munlock(2), mlockallde Géographie (2) et avec la munlockall(2). Ceci est obtenu par la cartographie de trois
pages contiguës, puis verrouiller la deuxième page, assurant ainsi la non contiguïté
les pages sont verrouillées. Ceci est ensuite répété jusqu'à ce que le maximum autorisé mlocks ou un
un maximum de 262144 mappages sont effectués. Ensuite, tous les futurs mappages sont verrouillés et le
le travailleur tente de mapper 262144 pages, puis toutes les pages sont déverrouillées et les pages sont
non mappé.

--mlock-ops N
arrêt après N mlock bogo opérations.

--mmap N
démarrer N travailleurs appelant en permanence mmap(2) /carte du monde(2). La cartographie initiale est un
gros morceau (taille spécifiée par --mmap-bytes) suivi de 4K pseudo-aléatoire
démappages, puis mappages 4K pseudo-aléatoires, puis démappages 4K linéaires. Noter
que cela peut amener les systèmes à déclencher le tueur OOM du noyau sur les systèmes Linux sinon
suffisamment de mémoire physique et l'échange n'est pas disponible. L'option MAP_POPULATE est utilisée
pour remplir les pages en mémoire sur les systèmes qui le prennent en charge. Par défaut, anonyme
mappages sont utilisés, cependant, les options --mmap-file et --mmap-async permettent de
effectuer des mappages basés sur des fichiers si vous le souhaitez.

--mmap-ops N
arrêter les travailleurs de stress mmap après les opérations N bogo.

--mmap-async
activer le mappage de mémoire basé sur des fichiers et utiliser la msync asynchrone sur chaque page, voir
--mmap-fichier.

--mmap-octets N
allouez N octets par travailleur de stress mmap, la valeur par défaut est de 256 Mo. On peut préciser le
taille en unités d'octets, Ko, MBytes et GBytes en utilisant le suffixe b, k, m ou g.

--mmap-fichier
activer le mappage de la mémoire basé sur les fichiers et par défaut utiliser la synchronisation synchrone sur chaque
.

--mmap-mprotect
modifier les paramètres de protection sur chaque page de mémoire. Chaque fois qu'une page ou un groupe de
les pages sont mappées ou remappées, cette option rendra les pages en lecture seule, en écriture
uniquement, exécutable uniquement et lecture-écriture.

--mmapfork N
démarrer N travailleurs qui forment chacun 32 processus enfants, chacun essayant de
allouer une partie de la mémoire libre laissée dans le système (et essayer d'éviter tout
échange). Les processus enfants indiquent alors que l'allocation sera nécessaire avec
fou(2) puis memset le à zéro et laisse entendre qu'il n'est plus nécessaire avec
madvise avant de sortir. Cela produit des quantités importantes d'activité VM, beaucoup de
cache manque et avec un minimum d'échange.

--mmapfork-ops N
arrêt après les opérations N mmapfork bogo.

--mmapmany N
démarrer N travailleurs qui tentent de créer la mémoire maximale autorisée par processus
mappages. Ceci est réalisé en mappant 3 pages contiguës, puis en démapper le
page du milieu divisant ainsi le mappage en deux. Ceci est ensuite répété jusqu'à ce que le
mappages maximum autorisés ou un maximum de 262144 mappages sont effectués.

--mmapmany-ops N
arrêt après N mmapmany opérations bogo.

--mremap N
démarrer N travailleurs appelant en permanence mmap(2), mremapde Géographie (2) et avec la carte du monde(2). La première
le mappage anonyme est un gros morceau (taille spécifiée par --mremap-bytes), puis
itérativement réduit de moitié en remappant jusqu'à une taille de page, puis
revenir à la taille d'origine. Ce nœud de calcul n'est disponible que pour Linux.

--mremap-ops N
arrêtez les travailleurs de stress mremap après les opérations N bogo.

--mremap-octets N
allouez initialement N octets par travailleur de stress de remappage, la valeur par défaut est de 256 Mo. On peut
spécifier la taille en unités d'octets, Koctets, MBytes et GBytes en utilisant le suffixe b,
k, m ou g.

--msg N
démarrer N processus expéditeur et destinataire qui envoient et reçoivent continuellement des messages
en utilisant le message System V IPC.

--msg-ops N
s'arrêter après N opérations d'envoi de message bogo terminées.

--mq N démarrer N processus expéditeur et destinataire qui envoient et reçoivent continuellement des messages
en utilisant les files d'attente de messages POSIX. (Linux uniquement).

--mq-ops N
s'arrêter après N bogo POSIX opérations d'envoi de message terminées.

--mq-taille N
spécifiez la taille de la file d'attente des messages POSIX. La taille par défaut est de 10 messages et la plupart des Linux
il s'agit de la taille maximale autorisée pour les utilisateurs normaux. Si la taille donnée est
supérieure à la taille de file d'attente de messages autorisée, un avertissement est émis et le
la taille maximale autorisée est utilisée à la place.

--joli N
démarrez N travailleurs consommant du processeur qui exercent les niveaux nice disponibles. Chaque
l'itération dérive d'un processus enfant qui parcourt tous les bons niveaux
exécuter une boucle occupée pendant 0.1 seconde par niveau, puis se termine.

--bonnes opérations N
arrêt après N nice bogo belles boucles

--nul N
démarrer N travailleurs écrivant dans /dev/null.

--opérations nulles N
arrêter les travailleurs de stress nul après N /dev/null bogo opérations d'écriture.

--numa N
démarrer N workers qui migrent les facteurs de stress et une mémoire tampon de 4 Mo mappée sur tous
les nœuds NUMA disponibles. Cela utilise migrer_pages(2) déplacer les facteurs de stress et
lierde Géographie (2) et avec la déplacer_pages(2) pour déplacer les pages du tampon mappé. Après chaque mouvement,
le tampon est écrit pour forcer l'activité sur le bus, ce qui entraîne des échecs dans le cache.
Ce test ne s'exécutera que sur du matériel avec NUMA activé et plus d'un nœud NUMA.

--numa-ops N
arrêter les travailleurs de stress NUMA après N opérations bogo NUMA.

--oom-tuyau N
démarrer N travailleurs qui créent autant de tuyaux que permis et exercer l'expansion et
réduire les tuyaux de la plus grande taille de tuyau à une taille de page. Les données sont écrites
dans les tuyaux et lisez à nouveau pour remplir les tampons des tuyaux. Avec le --agressif
mode activé les données ne sont pas lues lorsque les tuyaux sont rétrécis, provoquant le noyau
aux processus OOM de manière agressive. L'exécution de plusieurs instances de ce facteur de stress forcera
du noyau aux processus OOM en raison des nombreuses allocations de tampon de grande taille.

--oom-pipe-ops N
arrêt après les opérations d'expansion/rétrécissement du tuyau N bogo.

-o N, --ouvert N
démarrer N travailleurs qui effectuent ouvert(2) puis close(2) opérations sur /dev/zero. Les
le nombre maximal d'ouvertures à la fois est défini par le système, le test se déroulera donc jusqu'à ce
maximum, ou 65536 descripteurs de fichiers ouverts, selon la première occurrence.

--opérations ouvertes N
arrêter les travailleurs de stress ouverts après les opérations ouvertes N bogo.

--personnalité N
démarrer N travailleurs qui tentent de définir la personnalité et d'obtenir tous les
types de personnalité (types de domaine d'exécution de processus) via le personnalité(2) système
appel. (Linux uniquement).

--personnalité-ops N
arrêter les travailleurs du stress de la personnalité après les opérations de personnalité N bogo.

-p N, --tuyau N
démarrez N travailleurs qui effectuent des écritures et des lectures volumineuses sur les canaux pour exercer les E/S des canaux.
Cela exerce l'écriture et la lecture en mémoire ainsi que le changement de contexte. Chaque travailleur
a deux processus, un lecteur et un écrivain.

--pipe-ops N
arrêter les travailleurs de stress de tuyau après les opérations d'écriture de tuyau N bogo.

--pipe-data-size N
spécifie la taille en octets de chaque écriture dans le tube (plage de 4 octets à 4096
octets). La définition d'une petite taille de données entraînera la mise en mémoire tampon de plus d'écritures dans le
pipe, réduisant ainsi le taux de changement de contexte entre le rédacteur de pipe et la pipe
processus de lecture. La taille par défaut est la taille de la page.

--la taille du tuyau N
spécifie la taille du tuyau en octets (pour les systèmes qui prennent en charge le F_SETPIPE_SZ
commande fcntl()). La définition d'une petite taille de tuyau entraînera le remplissage et le blocage du tuyau
plus fréquemment, augmentant ainsi le taux de changement de contexte entre le rédacteur de pipe
et les processus de lecture de tuyaux. La taille par défaut est de 512 octets.

-P N, --sondage N
démarrer N travailleurs qui effectuent une interrogation sans délai d'attente via le po(2), Sélectionnerde Géographie (2) et avec la
sleep(3) appels. Cela fait perdre du temps au système et à l'utilisateur à ne rien faire.

--opérations de sondage N
arrêtez les travailleurs du sondage après les opérations de sondage N bogo.

--profs N
démarrer N travailleurs qui lisent les fichiers à partir de / proc et lire de manière récursive les fichiers de
/proc/auto (Linux uniquement).

--procfs-ops N
arrêter la lecture de procfs après N bogo reads. Attention, puisque le nombre d'entrées
peut varier d'un noyau à l'autre, cette métrique de bogo ops est probablement très trompeuse.

--pthread N
démarrer N travailleurs qui créent et terminent de manière itérative plusieurs pthreads (le
la valeur par défaut est 1024 pthreads par worker). À chaque itération, chaque pthread nouvellement créé
attend que le travailleur ait créé tous les pthreads, puis ils se terminent tous
ensemble.

--pthread-ops N
arrêter les travailleurs pthread après N bogo pthread create opérations.

--pthread-max N
créer N pthreads par travailleur. Si le produit du nombre de pthreads par le
le nombre de travailleurs est supérieur à la limite souple de pthreads autorisés, alors le
maximum est réajusté jusqu'au maximum autorisé.

--ptrace N
démarrer N travailleurs qui forment et tracent les appels système d'un processus enfant à l'aide
trace (2).

--ptrace-ops N
arrêter les travailleurs ptracer une fois que N appels système bogo ont été tracés.

-Q, --qsort N
démarrer N travailleurs qui trient les entiers 32 bits à l'aide de qsort.

--qsort-ops N
arrêter les travailleurs de stress qsort après N bogo qsorts.

--qsort-taille N
spécifiez le nombre d'entiers de 32 bits à trier, la valeur par défaut est 262144 (256 × 1024).

--quota N
démarrer N travailleurs qui exercent les Q_GETQUOTA, Q_GETFMT, Q_GETINFO, Q_GETSTATS et
Q_SYNC quotatl(2) commandes sur tous les systèmes de fichiers basés sur des blocs montés disponibles.

--quota-opérations N
arrêter les travailleurs de stress de quota après les opérations N bogo quotactl.

--rdrand N
démarrer N travailleurs qui lisent le générateur de nombres aléatoires matériel Intel (Intel
processeurs Ivybridge vers le haut).

--rdrand-ops N
arrêter les travailleurs stressés de rdrand après N opérations de rdrand de bogo (1 bogo op = 2048 aléatoire
bits lus avec succès).

--lire à l'avance N
démarrer N workers qui recherchent et effectuent de manière aléatoire des opérations d'E/S de lecture/écriture de 512 octets
sur un fichier avec readahead. La taille de fichier par défaut est de 1 Go. Les lectures anticipées et les lectures sont
regroupés en 16 lectures anticipées, puis 16 lectures.

--readahead-octets N
définir la taille du fichier readahead, la valeur par défaut est de 1 Go. On peut spécifier la taille dans
unités d'octets, Koctets, MBytes et GBytes en utilisant le suffixe b, k, m ou g.

--readahead-ops N
arrêter les travailleurs de stress readahead après N opérations de lecture bogo.

--remapper N
démarrez N travailleurs qui mappent 512 pages et réorganisez ces pages à l'aide de la méthode obsolète
appel système remap_file_pages(2). Plusieurs réorganisations de pages sont exercées : en avant,
inverse, aléatoire et plusieurs pages à 1 page.

--remap-ops N
arrêt après N opérations de remappage de bogo.

-R N, --Renommer N
démarrer N travailleurs qui créent chacun un fichier, puis le renommer à plusieurs reprises.

--renommer les opérations N
arrêtez de renommer les travailleurs stressés après N bogo renommer les opérations.

--rlimite N
démarrer N travailleurs qui dépassent les limites de ressources du processeur et de la taille du fichier, générant SIGXCPU
et les signaux SIGXFSZ.

--rlimit-ops N
s'arrêter après que les signaux SIGXCPU et SIGXFSZ à ressources limitées N bogo aient été interceptés.

--seccomp N
démarrer N travailleurs qui appliquent le filtrage des appels du système Secure Computing. Chaque travailleur
crée des processus enfants qui écrivent un court message dans /dev/null, puis se termine. 2%
des processus enfants ont un filtre seccomp qui interdit l'appel système d'écriture
et par conséquent, il est tué par seccomp avec un SIGSYS. Notez que ce facteur de stress peut
générer de nombreux messages de journal d'audit à chaque fois que l'enfant est tué.

--seccomp-ops N
arrêter les travailleurs de stress seccomp après N tests de filtre seccomp.

--chercher N
démarrer N workers qui recherchent et effectuent de manière aléatoire des opérations d'E/S de lecture/écriture de 512 octets
sur un fichier. La taille de fichier par défaut est de 16 Go.

--opérations de recherche N
arrêtez de chercher des travailleurs stressés après les opérations de recherche de N bogo.

--recherche-coup de poing
percez des trous de 8K situés au hasard dans le fichier pour que plus d'étendues forcent un plus
stresseur de recherche exigeant, (Linux uniquement).

--recherche-taille N
spécifiez la taille du fichier en octets. Les petites tailles de fichiers permettent aux E/S de se produire dans
le cache, entraînant une charge CPU plus importante. Les fichiers volumineux obligent davantage d'opérations d'E/S à
disque provoquant plus de temps d'attente et plus d'E/S sur le disque. On peut spécifier la taille dans
unités d'octets, Koctets, MBytes et GBytes en utilisant le suffixe b, k, m ou g.

--sem N
démarrer N travailleurs qui effectuent des opérations d'attente et de publication de sémaphore POSIX. Par défaut,
un parent et 4 enfants sont démarrés par travailleur pour fournir une certaine controverse sur le
sémaphore. Cela met l'accent sur les opérations de sémaphore rapides et produit un contexte rapide
commutation.

--sem-opérations N
arrêter les travailleurs de stress du sémaphore après les opérations de sémaphore N bogo.

--sem-procs N
démarrer N travailleurs enfants par travailleur pour fournir une contention sur le sémaphore, le
la valeur par défaut est 4 et un maximum de 64 est autorisé.

--sem-sysv N
démarrer N travailleurs qui effectuent des opérations d'attente et de publication de sémaphore System V. Par
par défaut, un parent et 4 enfants sont démarrés par travailleur pour fournir une certaine contention
sur le sémaphore. Cela met l'accent sur les opérations de sémaphore rapides et produit des
changement de contexte.

--sem-sysv-ops N
arrêter les travailleurs de stress du sémaphore après les opérations de sémaphore N bogo System V.

--sem-sysv-procs N
démarrer N processus enfants par travailleur pour fournir une contention sur le sémaphore System V,
la valeur par défaut est 4 et un maximum de 64 sont autorisés.

--envoyer le fichier N
démarrer N travailleurs qui envoient un fichier vide à /dev/null. Cette opération passe près de
tout le temps dans le noyau. La taille par défaut du fichier d'envoi est de 4 Mo. Le fichier d'envoi
les options sont pour Linux uniquement.

--sendfile-ops N
arrêter les travailleurs sendfile après N opérations sendfile bogo.

--sendfile-taille S
spécifiez la taille à copier avec chaque appel sendfile. La taille par défaut est de 4 Mo. Une
peut spécifier la taille en unités d'octets, Koctets, MBytes et GBytes en utilisant le suffixe
b, k, m ou g.

--shm N
démarrer N travailleurs qui ouvrent et allouent des objets de mémoire partagée à l'aide du POSIX partagé
interfaces mémoire. Par défaut, le test créera et détruira à plusieurs reprises 32
objets de mémoire partagée, chacun d'une taille de 8 Mo.

--shm-ops N
s'arrêter une fois que les opérations de création et de destruction de bogo de mémoire partagée N POSIX sont terminées.

--shm-octets N
spécifier la taille des objets de mémoire partagée POSIX à créer. On peut préciser
la taille en unités d'octets, Koctets, MBytes et GBytes en utilisant le suffixe b, k, m ou
g.

--shm-objs N
spécifier le nombre d'objets de mémoire partagée à créer.

--shm-sysv N
démarrer N workers qui allouent de la mémoire partagée à l'aide de la mémoire partagée System V
interface. Par défaut, le test créera et détruira à plusieurs reprises 8 mémoires partagées
segments, chacun d'une taille de 8 Mo.

--shm-sysv-ops N
s'arrêter une fois que N opérations de création et de destruction de bogo de mémoire partagée sont terminées.

--shm-sysv-octets N
spécifier la taille du segment de mémoire partagée à créer. On peut préciser le
taille en unités d'octets, Ko, MBytes et GBytes en utilisant le suffixe b, k, m ou g.

--shm-sysv-segs N
spécifier le nombre de segments de mémoire partagée à créer.

--sigfd N
démarrer N travailleurs qui génèrent des signaux SIGRT et sont gérés par des lectures par un enfant
processus à l'aide d'un descripteur de fichier configuré à l'aide signalfd(2). (Linux uniquement). Cette volonté
générer une charge de changement de contexte lourde lorsque tous les processeurs sont complètement chargés.

--sigfd-ops
arrêter les travailleurs sigfd après l'envoi de N signaux SIGUSR1.

--sigfpe N
démarrer N travailleurs qui provoquent rapidement la division par zéro des défauts SIGFPE.

--sigfpe-ops N
arrêter les travailleurs de stress sigfpe après N bogo défauts SIGFPE.

--signature N
démarrer N travailleurs qui vérifient si les signaux SIGUSR1 sont en attente. Ce facteur de stress masque
SIGUSR1, génère un signal SIGUSR1 et utilise signer(2) pour voir si le signal est
en attendant. Ensuite, il démasque le signal et vérifie si le signal n'est plus en attente.

--signending-ops N
arrêtez de signaler les travailleurs stressés après N bogo sigpendant les chèques en attente/non en attente.

--sigsegv N
démarrer N travailleurs qui créent et détectent rapidement des défauts de segmentation.

--sigsegv-ops N
arrêter les travailleurs de stress sigsegv après N erreurs de segmentation bogo.

--sigsuspendre N
démarrer N workers qui génèrent chacun 4 processus enfants qui attendent un SIGUSR1
signal du parent utilisant sigsuspendre(2). Le parent envoie des signaux SIGUSR1 à
chaque enfant en succession rapide. Chaque réveil sigsuspend est compté comme un bogo
fonctionnement.

--sigsuspend-opérations N
arrêter sigsuspend stress travailleurs après N bogo sigsuspend réveils.

--sigq N
démarrer N travailleurs qui envoient rapidement des signaux SIGUSR1 en utilisant file d'attente(3) à l'enfant
processus qui attendent le signal via sigwaitinfo (2).

--sigq-ops N
arrêter les travailleurs de stress sigq après les opérations d'envoi de signal N bogo.

--dormir N
démarrer N workers qui génèrent plusieurs threads qui effectuent chacun plusieurs veilles
des plages 1us à 0.1s. Cela crée plusieurs commutateurs de contexte et minuterie
interrompt.

--opérations de sommeil N
arrêt après N sommeil bogo opérations.

--sommeil-max P
démarrer P threads par travailleur. La valeur par défaut est 1024, le maximum autorisé est 30000.

-S N, --chaussette N
démarrer N travailleurs qui effectuent diverses activités de stress socket. Il s'agit d'une paire
des processus client/serveur effectuant une connexion, un envoi et une réception rapides et
se déconnecte sur l'hôte local.

--domaine-chaussette D
spécifiez le domaine à utiliser, la valeur par défaut est ipv4. Actuellement ipv4, ipv6 et unix sont
prise en charge.

--sock-nodelay
Cela désactive l'algorithme TCP Nagle, de sorte que les segments de données sont toujours envoyés dès que
possible. Cela empêche les données d'être mises en mémoire tampon avant d'être transmises, d'où
résultant en une moins bonne utilisation du réseau et plus de changements de contexte entre les
expéditeur et destinataire.

--port-chaussette P
démarrer au port de socket P. Pour les processus de travail de socket N, les ports P à P - 1 sont utilisés.

--chaussettes N
arrêter les travailleurs de stress socket après les opérations N bogo.

--chaussettes-opts [ envoyer | envoyermsg | envoyermmsg ]
par défaut, les messages sont envoyés en utilisant envoyer(2). Cette option permet de spécifier le
méthode d'envoi utilisant envoyer(2), envoyermsg(2) ou envoyermmsg(2). Notez que sendmmsg est
uniquement disponible pour les systèmes Linux qui prennent en charge cet appel système.

--sockfd N
démarrer N travailleurs qui transmettent des descripteurs de fichiers sur un socket de domaine UNIX à l'aide du
GMMC(3) mécanisme de données auxiliaires. Pour chaque worker, couple de processus client/serveur
sont créés, le serveur ouvre autant de descripteurs de fichiers sur /dev/null que possible et
en les transmettant via le socket à un client qui les lit à partir des données CMSG et
ferme immédiatement les fichiers.

--sockfd-ops N
arrêter les travailleurs de stress sockfd après les opérations de N bogo.

--paire de chaussettes N
démarrer N travailleurs qui effectuent des lectures/écritures d'E/S de paires de sockets. Cela implique une paire de
processus client/serveur effectuant des opérations d'E/S de socket de taille aléatoire.

--sockpair-ops N
arrêter les travailleurs stressés par paire de sockets après N opérations bogo.

--frayer N
start N travailleurs génèrent continuellement des enfants en utilisant posix_spawn(3) que exec stress-ng
puis quittez presque immédiatement.

--spawn-ops N
arrêter d'engendrer des travailleurs stressants après l'apparition de N bogo.

--épissure N
déplacer les données de /dev/zero vers /dev/null via un tube sans aucune copie entre
espace d'adressage du noyau et espace d'adressage utilisateur à l'aide épissure(2). Ceci est uniquement disponible
pour Linux.

--opérations d'épissage N
arrêt après N opérations d'épissure bogo.

--splice-octets N
transférez N octets par appel d'épissure, la valeur par défaut est 64 Ko. On peut spécifier la taille dans
unités d'octets, Koctets, MBytes et GBytes en utilisant le suffixe b, k, m ou g.

--empiler N
démarrer N travailleurs qui provoquent et attrapent rapidement des débordements de pile à l'aide de allouer (3).

--pile-full
l'action par défaut est de toucher la page la plus basse sur chaque allocation de pile. Cette
touche toutes les pages en remplissant la nouvelle allocation de pile avec des zéros qui
force l'allocation des pages physiques et est donc plus agressif.

--stack-ops N
arrêter les travailleurs stressés de la pile après le débordement de la pile N bogo.

--str N
démarrer N travailleurs qui exercent diverses fonctions de chaîne libc sur des chaînes aléatoires.

--str-méthode strfonc
sélectionnez une fonction de chaîne libc spécifique à souligner. Fonctions de chaîne disponibles pour
les contraintes sont : all, index, rindex, strcasecmp, strcat, strchr, strcoll, strcmp,
strcpy, strlen, strncasecmp, strncat, strncmp, strrchr et strxfrm. Voir un magnifique(3)
pour plus d'informations sur ces fonctions de chaîne. La méthode 'all' est la méthode par défaut
et exercera toutes les méthodes de chaîne.

--str-ops N
s'arrêter après N opérations de chaîne bogo.

--flux N
démarrer N travailleurs exerçant un stresseur de bande passante mémoire vaguement basé sur le STREAM
Outil d'analyse comparative « la bande passante de la mémoire durable dans les ordinateurs hautes performances » par
John D. McCalpin, Ph.D. Ce facteur de stress alloue des tampons qui sont au moins 4 fois
la taille du cache CPU L2 et effectue continuellement des rondes de suivi
calculs sur de grands tableaux de nombres à virgule flottante double précision :

Opération Description
copier c[i] = a[i]
échelle b[i] = scalaire * c[i]
ajouter c[i] = a[i] + b[i]
triade a[i] = b[i] + (c[i] * scalaire)

Étant donné que cela est vaguement basé sur une variante du code de référence STREAM, NE PAS
soumettre des résultats basés sur cela comme il est prévu de souligner juste pour souligner
mémoire et calcul et NON destiné au STREAM réglé ou non réglé avec précision
benchmarking que ce soit. Utilisez l'outil d'analyse comparative officiel STREAM si vous le souhaitez
repères STREAM précis et standardisés.

--stream-ops N
s'arrêter après N opérations de bogo de flux, où une opération de bogo est un cycle de copie,
opérations d'échelle, d'addition et de triade.

--stream-l3-taille N
Spécifiez la taille du cache de niveau 3 du processeur en octets. On peut spécifier la taille en unités de
Octets, Ko, Mo et Go en utilisant le suffixe b, k, m ou g. Si le cache L3
size n'est pas fourni, alors stress-ng tentera de déterminer la taille du cache, et
à défaut, la taille par défaut sera de 4 Mo.

-s N, --changer N
démarrer N travailleurs qui envoient des messages via un canal à un enfant pour forcer le changement de contexte.

--switch-ops N
arrêter les travailleurs de changement de contexte après N opérations bogo.

--lien symbolique N
démarrer N travailleurs créant et supprimant des liens symboliques.

--symlink-ops N
arrêter les travailleurs de stress de lien symbolique après les opérations N bogo.

--sync-fichier N
démarrer N travailleurs qui effectuent une gamme de synchronisations de données sur un fichier à l'aide
sync_file_range(2). Trois mélanges de synchronisations sont effectués, du début à la fin de
le fichier, de la fin du fichier au début, et un mélange aléatoire. Une sélection aléatoire
de types de synchronisation valides sont utilisés, couvrant le SYNC_FILE_RANGE_WAIT_BEFORE,
Les bits d'indicateur SYNC_FILE_RANGE_WRITE et SYNC_FILE_RANGE_WAIT_AFTER.

--sync-file-ops N
arrêter les travailleurs du fichier de synchronisation après N opérations de synchronisation bogo.

--sync-file-bytes N
spécifiez la taille du fichier à synchroniser. On peut spécifier la taille en unités de
Octets, Ko, Mo et Go en utilisant le suffixe b, k, m ou g.

--sysinfo N
démarrer N travailleurs qui lisent en permanence le système et traitent des informations spécifiques.
Celui-ci lit les heures de l'utilisateur du processus et du système à l'aide de la fois(2) appel système. Pour
systèmes Linux, il lit également les statistiques globales du système en utilisant le Sysinfo(2) système
appel ainsi que les statistiques du système de fichiers pour tous les systèmes de fichiers montés utilisant
statistiques (2).

--sysinfo-ops N
arrêter les travailleurs sysinfo après N opérations bogo.

--sysfs N
démarrer N travailleurs qui lisent récursivement des fichiers à partir de / sys (Linux uniquement). Cela peut causer
pilotes de noyau spécifiques pour émettre des messages dans le journal du noyau.

--sys-ops N
arrêter la lecture de sysfs après N opérations de lecture bogo. Attention, puisque le nombre d'entrées
peut varier d'un noyau à l'autre, cette métrique de bogo ops est probablement très trompeuse.

--tee N
déplacer les données d'un processus d'écriture vers un processus de lecture via des canaux et vers /dev/null
sans aucune copie entre l'espace d'adressage du noyau et l'espace d'adressage utilisateur en utilisant
tee(2). Ceci n'est disponible que pour Linux.

--te-ops N
arrêt après N opérations bogo tee.

-T N, --minuteur N
démarrer N travailleurs créant des événements de minuterie à un taux par défaut de 1 MHz (Linux uniquement) ; cette
peut créer plusieurs milliers d'interruptions d'horloge de minuterie. Chaque événement de minuterie est capturé
par un gestionnaire de signal et compté comme un bogo timer op.

--timer-ops N
arrêter les travailleurs de stress de la minuterie après N événements de minuterie bogo (Linux uniquement).

--timer-freq F
exécuter des minuteries à F Hz ; plage de 1 à 1000000000 Hz (Linux uniquement). En sélectionnant un
Une contrainte de fréquence appropriée peut générer des centaines de milliers d'interruptions
par seconde.

--timer-rand
sélectionnez une fréquence de minuterie basée sur la fréquence de minuterie +/- 12.5% de gigue aléatoire.
Cela essaie de forcer plus de variabilité dans l'intervalle de minuterie pour rendre la planification
moins prévisible.

--timerfd N
démarrer N travailleurs créant des événements timerfd à un taux par défaut de 1 MHz (Linux uniquement) ;
cela peut créer plusieurs milliers d'événements d'horloge de minuterie. Les événements de minuterie sont attendus
sur le descripteur de fichier timer en utilisant Sélectionner(2) puis lu et compté comme un bogo
timerfd op.

--timerfd-ops N
arrêter timerfd stress workers après N bogo timerfd événements (Linux uniquement).

--timerfd-freq F
exécuter des minuteries à F Hz ; plage de 1 à 1000000000 Hz (Linux uniquement). En sélectionnant un
Une contrainte de fréquence appropriée peut générer des centaines de milliers d'interruptions
par seconde.

--timerfd-rand
sélectionnez une fréquence timerfd basée sur la fréquence de la minuterie +/- 12.5% aléatoire
gigue. Cela essaie de forcer plus de variabilité dans l'intervalle de minuterie pour rendre le
planification moins prévisible.

--tsc N
démarrer N travailleurs qui lisent le compteur d'horodatage (TSC) 256 fois par itération de boucle
(opération bogo). Disponible uniquement sur les plates-formes Intel x86.

--tsc-ops N
arrêter les travailleurs de tsc une fois les opérations N bogo terminées.

--tsearch N
démarrer N travailleurs qui insèrent, recherchent et suppriment des entiers 32 bits sur un arbre binaire
grâce à recherche(3), trouverde Géographie (3) et avec la supprimer(3). Par défaut, il y a 65536 randomisés
entiers utilisés dans l'arbre. Il s'agit d'une méthode utile pour exercer un accès aléatoire de
mémoire et cache du processeur.

--tsearch-ops N
arrêter les tchercheurs une fois les opérations de N bogo tree terminées.

--tsearch-taille N
spécifiez la taille (nombre d'entiers de 32 bits) dans le tableau à rechercher. La taille peut être
de 1K à 4M.

--udp N
démarrer N travailleurs qui transmettent des données à l'aide d'UDP. Il s'agit d'un couple client/serveur
processus effectuant des connexions, des envois, des réceptions et des déconnexions rapides au niveau local
hôte.

--udp-domaine D
spécifiez le domaine à utiliser, la valeur par défaut est ipv4. Actuellement ipv4, ipv6 et unix sont
prise en charge.

--udp-lite
utiliser le protocole UDP-Lite (RFC 3828) (uniquement pour les domaines ipv4 et ipv4).

--udp-ops N
arrêter les travailleurs de stress udp après les opérations N bogo.

--udp-port P
démarrer au port P. Pour les processus de travail N udp, les ports P à P - 1 sont utilisés. Par défaut,
les ports 7000 et plus sont utilisés.

--udp-inondation N
démarrez N travailleurs qui tentent d'inonder l'hôte avec des paquets UDP vers des ports aléatoires.
L'adresse IP des paquets n'est actuellement pas usurpée. Ceci n'est disponible que sur
systèmes qui prennent en charge AF_PACKET.

--udp-domaine-inondation D
spécifiez le domaine à utiliser, la valeur par défaut est ipv4. Actuellement ipv4 et ipv6 sont
prise en charge.

--udp-inondations-ops N
arrêter les travailleurs stressés par les inondations udp après les opérations de N bogo.

--annuler le partage N
démarrer N travailleurs qui forment chacun 32 processus enfants, dont chacun exerce le
ne pas partager(2) appel système en dissociant des parties du contexte d'exécution du processus.
(Linux uniquement).

--unshare-ops N
arrêter après N bogo unshare opérations.

-u N, --urandom N
démarrer N travailleurs en lisant /dev/urandom (Linux uniquement). Cela chargera le noyau au hasard
source du nombre.

--urandom-ops N
arrêter les travailleurs de stress urandom après les opérations de lecture N urandom bogo (Linux uniquement).

--userfaultfd N
démarrer N travailleurs qui génèrent des défauts de page d'écriture sur un petit mappé anonymement
région mémoire et gérer ces défauts à l'aide de la gestion des défauts de l'espace utilisateur via le
mécanisme userfaultfd. Cela générera une grande quantité de défauts de page majeurs et
également des changements de contexte lors de la gestion des défauts de page. (Linux uniquement).

--userfaultfd-ops N
arrêter les travailleurs de stress userfaultfd après N défauts de page.

--userfaultfd-octets N
mmap N octets par travailleur userfaultfd sur la faute de page, la valeur par défaut est de 16 Mo
spécifier la taille en unités d'octets, Koctets, MBytes et GBytes en utilisant le suffixe b,
k, m ou g.

--utime N
démarrer N travailleurs mettant à jour les horodatages des fichiers. Ceci est principalement lié au processeur lorsque la valeur par défaut
est utilisé car le système vide les modifications de métadonnées uniquement périodiquement.

--utime-ops N
arrêtez les travailleurs de stress utime après les opérations de N utime bogo.

--utime-fsync
forcer les changements de métadonnées à chaque mise à jour d'horodatage de fichier à être vidés sur le disque. Cette
force le test à devenir lié aux E/S et entraînera de nombreuses écritures de métadonnées modifiées.

--vecmath N
démarrer N travailleurs qui effectuent diverses opérations mathématiques d'entiers non signés sur divers
vecteurs 128 bits. Un mélange d'opérations mathématiques vectorielles est effectué sur les éléments suivants
vecteurs : 16 × 8 bits, 8 × 16 bits, 4 × 32 bits, 2 × 64 bits. Les métriques produites
par ce mix dépendent de l'architecture du processeur et des optimisations mathématiques vectorielles
produit par le compilateur.

--vecmath-ops N
arrêt après N bogo opérations mathématiques sur les entiers vectoriels.

--vfork N
démarrer N travailleurs qui forment continuellement des enfants qui sortent immédiatement.

--vfork-ops N
arrêtez les travailleurs stressés de vfork après les opérations de N bogo.

--vfork-max P
créer des processus P, puis attendre qu'ils se terminent par itération. La valeur par défaut est
seulement 1; des valeurs plus élevées créeront de nombreux processus zombies temporaires en attente
être récolté. On peut potentiellement remplir la table de processus en utilisant des valeurs élevées
pour --vfork-max et --vfork.

-m N, --VM N
démarrer N travailleurs appelant en permanence mmap(2) /carte du monde(2) et en écrivant à l'alloué
Mémoire. Notez que cela peut amener les systèmes à déclencher le tueur OOM du noyau sous Linux
systèmes s'il n'y a pas assez de mémoire physique et d'échange n'est pas disponible.

--vm-octets N
mmap N octets par vm worker, la valeur par défaut est de 256 Mo. On peut spécifier la taille en unités
d'octets, Ko, Mo et Go en utilisant le suffixe b, k, m ou g.

--vm-foulée N
obsolète depuis la version 0.03.02

--vm-ops N
arrêter les travailleurs vm après les opérations N bogo.

--vm-accrocher N
sleep N secondes avant de démapper la mémoire, la valeur par défaut est de zéro seconde. Spécification de 0
fera une attente infinie.

--vm-garder
ne démapper et mapper pas continuellement la mémoire, continuez simplement à la réécrire.

--vm-verrouillé
Verrouillez les pages de la région mappée en mémoire à l'aide de mmap MAP_LOCKED (depuis Linux
2.5.37). Ceci est similaire au verrouillage de la mémoire comme décrit dans mlock (2).

--vm-méthode m
spécifier une méthode de contrainte vm. Par défaut, toutes les méthodes de stress sont exercées
séquentiellement, cependant on peut spécifier une seule méthode à utiliser si nécessaire. Chaque
des travailleurs vm ont 3 phases :

1. Initialisé. La région mappée en mémoire de manière anonyme est définie sur un modèle connu.

2. Exercé. La mémoire est modifiée d'une manière connue et prévisible. Certains travailleurs vm modifient
mémoire séquentiellement, certains utilisent de petites ou de grandes foulées pour avancer dans la mémoire.

3. Vérifié. La mémoire modifiée est vérifiée pour voir si elle correspond à la mémoire attendue
résultat.

Les méthodes vm contenant 'prime' dans leur nom ont une foulée du plus grand nombre premier
moins de 2^64, leur permettant de parcourir à fond la mémoire et de toucher à tous
emplacements une seule fois tout en évitant de toucher les cellules mémoire à côté de chaque
autre. Cette stratégie exerce la non-localité du cache et de la page.

Étant donné que la mémoire en cours d'exercice est virtuellement mappée, il n'y a aucune garantie de
toucher les adresses des pages dans un ordre physique particulier. Ces travailleurs ne devraient pas
être utilisé pour tester que toute la mémoire du système fonctionne correctement soit, utilisez des outils
comme memtest86 à la place.

Les méthodes de stress vm sont destinées à exercer la mémoire de manière à éventuellement trouver
problèmes de mémoire et d'essayer de forcer les erreurs thermiques.

Les méthodes de contrainte vm disponibles sont décrites comme suit :

Méthode Description
tous itérer sur toutes les méthodes de contrainte vm comme indiqué ci-dessous.
retournez séquentiellement travailler à travers la mémoire 8 fois, à chaque fois juste
un bit en mémoire inversé (inversé). Cela permettra effectivement
inverser chaque octet en 8 passes.
galpat-0 galop des zéros de motif. Cela met tous les bits à 0 et retourne
juste 1 sur 4096 bits à 1. Il vérifie ensuite si les 1
sont ramenés à 0 par leurs voisins ou des
les voisins ont été tirés jusqu'à 1.
galpat-1 galopants. Cela met tous les bits à 1 et retourne
juste 1 sur 4096 bits à 0. Il vérifie ensuite si les 0
sont tirés jusqu'à 1 par leurs voisins ou des voisins
ont été ramenés à 0.
gray remplir la mémoire avec des codes gray séquentiels (ceux-ci seulement
changer 1 bit à la fois entre les octets adjacents) puis
vérifiez s'ils sont correctement réglés.
incdec fonctionne séquentiellement à travers la mémoire deux fois, la première passe
incrémente chaque octet d'une valeur spécifique et le second
passe décrémente chaque octet à la valeur de départ d'origine.
La valeur d'incrémentation/décrémentation change à chaque appel de
le stresseur.
inc-nybble initialise la mémoire à une valeur définie (qui change à chaque
invocation du facteur de stress) et ensuite travailler de manière séquentielle
à travers chaque octet en incrémentant les 4 derniers bits de 1 et
les 4 premiers bits par 15.
rand-set fonctionne séquentiellement à travers la mémoire dans un réglage de morceaux de 64 bits
octets dans le morceau à la même valeur aléatoire de 8 bits. Les
la valeur aléatoire change sur chaque morceau. Vérifiez que les valeurs
n'ont pas changé.
rand-sum définit séquentiellement toute la mémoire sur des valeurs aléatoires, puis
additionner le nombre de bits qui ont changé depuis le
valeurs de consigne d'origine.
read64 lit séquentiellement la mémoire en utilisant des lectures 32 x 64 bits par bogo
boucle. Chaque boucle équivaut à une opération bogo. Cette
exerce les lectures de mémoire brute.
ou remplir la mémoire avec un motif aléatoire, puis séquentiellement
faire pivoter 64 bits de mémoire à droite d'un bit, puis vérifier le
charge finale/rotation/valeurs stockées.
échanger la mémoire de remplissage en morceaux de 64 octets avec des motifs aléatoires. Puis
échangez chaque bloc de 64 avec un bloc choisi au hasard. Finalement,
inverser le swap pour remettre les morceaux à leur original
place et vérifiez si les données sont correctes. Cet exercice
chargement/magasins de mémoire adjacents et aléatoires.
move-inv remplit séquentiellement la mémoire 64 bits de mémoire à la fois avec
valeurs aléatoires, puis vérifiez si la mémoire est définie
correctement. Ensuite, inversez séquentiellement chaque modèle de 64 bits
et vérifiez à nouveau si la mémoire est définie comme prévu.

modulo-x remplit la mémoire sur 23 itérations. Chaque itération commence un
octet plus loin du début de la mémoire et des étapes
par pas de 23 octets. A chaque foulée, le premier octet est
défini sur un modèle aléatoire et tous les autres octets sont définis sur le
inverse. Ensuite, il vérifie si le premier octet contient le
motif aléatoire attendu. Cela exerce la mémoire cache/lecture
ainsi que de voir si les cellules voisines influencent chacune
d'autre part.
prime-0 itérer 8 fois en parcourant la mémoire en très grand
les premiers pas s'effacent petit à petit dans chaque octet.
Vérifiez ensuite si tous les bits sont mis à zéro.
prime-1 itérer 8 fois en parcourant la mémoire en très grand
premiers pas en définissant juste un bit à la fois dans chaque octet.
Vérifiez ensuite si tous les bits sont définis sur un.
prime-gray-0 premier pas dans la mémoire à très grandes foulées
effacement juste sur le bit (basé sur un code gray) dans chaque octet.
Ensuite, répétez ceci mais effacez les 7 autres bits. Vérifiez ensuite pour
voir si tous les bits sont mis à zéro.
prime-gray-1 premier pas dans la mémoire à très grandes foulées
réglage juste sur le bit (basé sur un code gray) dans chaque octet.
Ensuite, répétez ceci mais définissez les 7 autres bits. Vérifiez ensuite pour
voir si tous les bits sont mis à un.
Rowhammer essaie de forcer la corruption de la mémoire en utilisant la mémoire Rowhammer
facteur de stress. Cela récupère deux entiers 32 bits de la mémoire et
force un vidage du cache sur les deux adresses plusieurs fois.
Cela est connu pour forcer le basculement des bits sur certains matériels,
en particulier avec des cycles de rafraîchissement de la mémoire à basse fréquence.
walk-0d pour chaque octet en mémoire, parcourir chaque ligne de données
les régler sur bas (et les autres sont sur hauts) et vérifier
que la valeur écrite est comme prévu. Cela vérifie le cas échéant
les lignes de données sont bloquées.
walk-1d pour chaque octet en mémoire, parcourir chaque ligne de données
les régler sur haut (et les autres sur bas) et vérifier
que la valeur écrite est comme prévu. Cela vérifie le cas échéant
les lignes de données sont bloquées.
walk-0a dans le mappage de mémoire donné, fonctionne à travers une gamme de
adresses spécialement choisies via des lignes d'adresse pour
voir si des lignes d'adresse sont bloquées bas. Cela fonctionne mieux
avec l'adressage de la mémoire physique, cependant, en exerçant ces
les adresses virtuelles ont aussi une certaine valeur.
walk-1a dans le mappage de mémoire donné, fonctionne à travers une gamme de
adresses spécialement choisies via des lignes d'adresse pour
voir si des lignes d'adresse sont bloquées haut. Cela fonctionne mieux
avec l'adressage de la mémoire physique, cependant, en exerçant ces
les adresses virtuelles ont aussi une certaine valeur.
write64 écrit séquentiellement la mémoire en utilisant des écritures 32 x 64 bits par bogo
boucle. Chaque boucle équivaut à une opération bogo. Cette
exerce les écritures de mémoire brute. Notez que les écritures en mémoire sont
pas vérifié à la fin de chaque itération de test.
zéro-un met tous les bits de mémoire à zéro, puis vérifie si des bits sont
pas zéro. Ensuite, définissez tous les bits de mémoire sur un et vérifiez si
tous les bits n'en sont pas un.

--vm-populer
remplir les tables de pages (prédéfaut) pour les mappages de mémoire ; cela peut stresser l'échange.
Uniquement disponible sur les systèmes prenant en charge MAP_POPULATE (depuis Linux 2.5.46).

--vm-rw N
démarrer N workers qui transfèrent de la mémoire vers/depuis un parent/enfant en utilisant
processus_vm_writevde Géographie (2) et avec la processus_vm_readv(2). Cette fonctionnalité n'est prise en charge que sur
Linux. Les transferts de mémoire ne sont vérifiés que si l'option --verify est activée.

--vm-rw-ops N
arrêter les travailleurs vm-rw après N lectures/écritures en mémoire.

--vm-rw-octets N
mmap N octets par vm-rw worker, la valeur par défaut est de 16 Mo. On peut spécifier la taille dans
unités d'octets, Koctets, MBytes et GBytes en utilisant le suffixe b, k, m ou g.

--vm-épissure N
déplacer les données de la mémoire vers /dev/null via un tube sans aucune copie entre
espace d'adressage du noyau et espace d'adressage utilisateur à l'aide vmsplicede Géographie (2) et avec la épissure(2). Cette
n'est disponible que pour Linux.

--vm-splice-ops N
arrêt après N bogo vm-splice opérations.

--vm-splice-octets N
transférez N octets par appel vmsplice, la valeur par défaut est 64 Ko. On peut spécifier la taille dans
unités d'octets, Koctets, MBytes et GBytes en utilisant le suffixe b, k, m ou g.

--attendre N
démarrer N travailleurs qui engendrent deux enfants ; on tourne dans un pause(2) boucle, le
l'autre s'arrête continuellement et continue le premier. Le processus de contrôle attend
le premier enfant à reprendre par la livraison de SIGCONT en utilisant attendre pidde Géographie (2) et avec la
attendre (2).

--attente-ops N
arrêt après N bogo wait opérations.

--wcs N
démarrer N travailleurs qui exercent diverses fonctions de chaîne de caractères larges libc sur
chaînes aléatoires.

--wcs-méthode wcsfunc
sélectionnez une fonction de chaîne de caractères large libc spécifique à souligner. Chaîne disponible
les fonctions à souligner sont : all, wcscasecmp, wcscat, wcschr, wcscoll, wcscmp, wcscpy,
wcslen, wcsncasecmp, wcsncat, wcsncmp, wcsrchr et wcsxfrm. La méthode "tout" est
la valeur par défaut et exercera toutes les méthodes de chaîne.

--wcs-ops N
s'arrêter après N bogo opérations de chaîne de caractères larges.

--xattr N
démarrer N travailleurs qui créent, mettent à jour et suppriment des lots d'attributs étendus sur un
fichier.

--xattr-ops N
arrêt après N bogo opérations d'attributs étendus.

-y N, --rendement N
démarrer N travailleurs qui appellent rendement_schedulé(2). Ce facteur de stress garantit qu'au moins 2
processus enfants par exercice CPU bouclier_rendement(2) quel que soit le nombre de travailleurs
spécifié, assurant ainsi toujours un changement de contexte rapide.

--rendement-ops N
arrêter les travailleurs de stress de rendement après N rendement_schedulé(2) opérations bogo.

--zéro N
démarrer N travailleurs en lisant /dev/zero.

--zéro-ops N
arrêter les travailleurs sans stress après les opérations de lecture N /dev/zero bogo.

--zlib N
démarrer N travailleurs compressant et décompressant des données aléatoires à l'aide de zlib. Chaque travailleur
a deux processus, l'un qui compresse les données aléatoires et les dirige vers un autre processus
qui décompresse les données. Ce facteur de stress sollicite le processeur, le cache et la mémoire.

--zlib-ops N
arrêt après N opérations de compression bogo, chaque opération de compression bogo est un
compression de 64 Ko de données aléatoires au niveau de compression le plus élevé.

--zombi N
démarrer N travailleurs qui créent des processus zombies. Celui-ci tentera rapidement de créer un
par défaut 8192 processus enfants qui meurent immédiatement et attendent dans un état zombie
jusqu'à ce qu'ils soient récoltés. Une fois le nombre maximum de processus atteint (ou fork
échoue parce que l'on a atteint le nombre maximum autorisé d'enfants) le plus ancien
l'enfant est fauché et un nouveau processus est alors créé selon le principe du premier entré, premier sorti,
puis répété.

--zombie-ops N
arrêtez les travailleurs du stress zombie après les opérations de zombies N bogo.

--zombie-max N
essayez de créer jusqu'à N processus zombies. Ceci peut ne pas être atteint si le système
limite est inférieure à N.

EXEMPLES

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

fonctionne pendant 60 secondes avec 4 facteurs de stress cpu, 2 facteurs de stress io et 1 facteur de stress vm en utilisant
1 Go de mémoire virtuelle.

stress-ng --cpu 8 --cpu-ops 800000

exécute 8 facteurs de stress du processeur et s'arrête après 800000 XNUMX opérations bogo.

stress-ng --sequential 2 --timeout 2m --metrics

exécuter 2 instances simultanées de tous les facteurs de stress séquentiellement un par un, chacun pour
2 minutes et résumer avec des mesures de performance à la fin.

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

exécuter 4 facteurs de stress cpu FFT, arrêter après 10000 opérations bogo et produire un résumé
juste pour les résultats FFT.

stress-ng --cpu 0 --cpu-method all -t 1h

exécuter des facteurs de stress cpu sur tous les processeurs en ligne fonctionnant à travers tous les processeurs disponibles
facteurs de stress pendant 1 heure.

stress-ng --tous les 4 --timeout 5m

exécuter 4 instances de tous les facteurs de stress pendant 5 minutes.

stress-ng --aléatoire 64

exécuter 64 facteurs de stress choisis au hasard parmi tous les facteurs de stress disponibles.

stress-ng --cpu 64 --cpu-method all --verify -t 10m --metrics-brief

exécutez 64 instances de tous les différents facteurs de stress du processeur et vérifiez que le
les calculs sont corrects pendant 10 minutes avec un résumé des opérations bogo à la fin.

contrainte-ng --séquentiel 0 -t 10m

exécuter tous les facteurs de stress un par un pendant 10 minutes, avec le nombre d'instances de
chaque facteur de stress correspondant au nombre de processeurs en ligne.

stress-ng --sequential 8 --class io -t 5m --times

exécuter tous les facteurs de stress de la classe io un par un pendant 5 minutes chacun, avec 8
instances de chaque facteur de stress s'exécutant simultanément et montrant l'utilisation globale du temps
statistiques à la fin de la course.

stress-ng --all 0 --maximize --aggressive

exécuter tous les facteurs de stress (1 instance de chacun par CPU) simultanément, maximiser le
paramètres (taille de mémoire, allocations de fichiers, etc.) et sélectionnez le plus
options exigeantes/agressives.

stress-ng --random 32 -x numa, disque dur, clé

exécuter 32 facteurs de stress sélectionnés au hasard et exclure les facteurs de stress numa, hdd et key

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

exécuter 4 instances des facteurs de stress VM l'une après l'autre, à l'exclusion du bigheap,
facteurs de stress brk et stack

EXIT STATUT

Statut Description
0 Succès.
1 erreur ; des options utilisateur incorrectes ou un problème de ressource fatal dans le stress-ng
harnais de stress (par exemple, manque de mémoire).
2 Un ou plusieurs facteurs de stress ont échoué.
3 Un ou plusieurs facteurs de stress n'ont pas pu s'initialiser en raison d'un manque de ressources, par
exemple ENOMEM (pas de mémoire) et ENOSPC (pas d'espace sur le système de fichiers).

Utilisez stress-ng en ligne en utilisant les services onworks.net