stress-ng - Online in der Cloud

PROGRAMM:

NAME/FUNKTION

stress-ng - ein Werkzeug zum Laden und Stressen eines Computersystems

ZUSAMMENFASSUNG

Stress-ng [zur Auswahl [ARG]] ...

BESCHREIBUNG

stress-ng wird ein Computersystem auf verschiedene wählbare Weise einem Stresstest unterziehen. Es wurde entworfen
verschiedene physikalische Subsysteme eines Computers sowie die verschiedenen Betriebs
Systemkernel-Schnittstellen. stress-ng bietet auch eine breite Palette von CPU-spezifischen Stresstests
die Gleitkomma-, Integer-, Bit-Manipulation und Kontrollfluss ausüben.

stress-ng war ursprünglich dazu gedacht, eine Maschine hart arbeiten zu lassen und Hardwareprobleme auszulösen
wie thermische Überläufe sowie Betriebssystemfehler, die nur auftreten, wenn ein System
hart verprügelt werden. Verwenden Sie Stress-ng mit Vorsicht, da einige der Tests ein System zum Laufen bringen können
heiß auf schlecht konzipierter Hardware und kann auch zu übermäßigem System-Thrashing führen, das möglicherweise
schwer zu stoppen.

stress-ng kann auch Testdurchsatzraten messen; das kann nützlich sein zu beobachten
Leistungsänderungen über verschiedene Betriebssystemversionen oder Hardwaretypen hinweg.
Es war jedoch nie dafür gedacht, als präzise Benchmark-Testsuite verwendet zu werden
Verwenden Sie es NICHT auf diese Weise.

Wenn stress-ng mit Root-Rechten ausgeführt wird, werden die Speichereinstellungen auf Linux-Systemen angepasst.
Um die Stressoren in Situationen mit niedrigem Gedächtnis unkillbar zu machen, verwenden Sie dies also mit Bedacht. Mit
das entsprechende Privileg, Stress-ng kann es erlauben, dass die Ionenklasse und die Ionenniveaus eingestellt werden
Auch hier sollte dies mit Vorsicht verwendet werden.

Man kann die Anzahl der Prozesse angeben, die pro Stresstesttyp aufgerufen werden sollen; Angabe von a
negativer Wert oder Nullwert wählt die Anzahl der verfügbaren Prozessoren, wie definiert durch
sysconf(_SC_NPROCESSORS_CONF).

OPTIONAL

Allgemein Stress-ng Smartgeräte App Optionen:

--aggressiv
ermöglicht mehr Datei-, Cache- und Speicherangriffsoptionen. Dies kann Tests verlangsamen,
Erhöhen Sie die Latenzen und reduzieren Sie die Anzahl der Bogo-Ops sowie die Änderung der
Balance zwischen Benutzerzeit und verwendeter Systemzeit, abhängig von der Art des Stressors
benutzt.

-a N, --alle N
Starten Sie N Instanzen jedes Stressors. Wenn N kleiner als Null ist, dann ist die Anzahl der CPUs
online wird für die Anzahl der Instanzen verwendet. Wenn N null ist, dann ist die Anzahl der CPUs
im System verwendet wird.

-b N, --backoff N
warten Sie N Mikrosekunden zwischen dem Start jedes Stress-Worker-Prozesses. Dies erlaubt
eine, um die Stresstests im Laufe der Zeit zu steigern.

--Klasse Name
Geben Sie die Klasse der Stressoren an, die ausgeführt werden sollen. Stressoren werden in eine oder mehrere der folgenden Kategorien eingeteilt:
die folgenden Klassen: CPU, CPU-Cache, Gerät, io, Interrupt, Dateisystem, Speicher,
Netzwerk, Betriebssystem, Pipe, Scheduler und VM. Einige Stressoren fallen in nur eine Klasse. Zum
Beispiel: Der Stressor 'get' ist nur in der Klasse 'os'. Andere Stressoren fallen in
mehr als eine Klasse, zum Beispiel fällt der Stressor 'lsearch' in die 'CPU',
'cpu-cache'- und 'memory'-Klassen, da es alle diese drei ausübt. Auswahl a
Eine bestimmte Klasse führt alle Stressoren aus, die in diese Klasse fallen, nur wenn sie ausgeführt wird
mit der Option --sequential.

-nicht, --Probelauf
Parse-Optionen, aber führen Sie keine Stresstests durch. Ein No-Op.

-H, --help
Zeig Hilfe.

--ignite-cpu
Kernel-Steuerelemente ändern, um zu versuchen, die CPU zu maximieren. Dies erfordert Root-Rechte, um
verschiedene ändern / sys Schnittstellenkontrollen. Derzeit funktioniert dies nur für Intel P-State
aktivierte x86-Systeme unter Linux.

--ionice-Klasse Klasse
Ionic-Klasse angeben (nur unter Linux). Kann im Leerlauf sein (Standard), besteffort, sein,
Echtzeit, rt.

--ionice-level Grad des
Ionic-Level angeben (nur unter Linux). Für Leerlauf ist 0 die einzig mögliche Option. Zum
besteffort oder realtime Werte 0 (höchste Priorität) bis 7 (niedrigste Priorität). Sehen
ionisieren(1) für weitere Details.

-k, --Behalte-Name
standardmäßig versucht stress-ng, den Namen der Stressprozesse zu ändern
nach ihrer Funktionalität; diese Option deaktiviert dies und behält den Prozess bei
name soll der Name des übergeordneten Prozesses sein, d. h. stress-ng.

--log-brief
standardmäßig meldet stress-ng den Namen des Programms, den Nachrichtentyp und die
Prozess-ID als Präfix für alle Ausgaben. Die Option --log-brief gibt Meldungen aus
ohne diese Felder, um eine weniger ausführliche Ausgabe zu erzeugen.

--Logdatei Dateinamen
Nachrichten in die angegebene Protokolldatei schreiben.

--maximieren
überschreibt die Standard-Stressor-Einstellungen und setzt diese stattdessen auf das Maximum
Einstellungen erlaubt. Diese Voreinstellungen können immer vom jeweiligen Stressor überschrieben werden
Einstellungsmöglichkeiten bei Bedarf.

--metriken
Ausgangsanzahl der von den Stressprozessen insgesamt durchgeführten Bogo-Operationen. Notiz
dass dies keine zuverlässige Kennzahl für Leistung oder Durchsatz ist und dies nicht der Fall war
entwickelt, um für Benchmarking verwendet zu werden. Die Metriken sind nur ein nützlicher Weg
um zu beobachten, wie sich ein System unter verschiedenen Lasten verhält.

Die folgenden Informationsspalten werden ausgegeben:

Kolonne Überschrift Erläuterung
bogo ops Anzahl der Iterationen des Stressors während des Laufs.
Dies ist ein Maß dafür, wie viel "Arbeit" insgesamt war
im Bogo-Betrieb erreicht.
Echtzeit (Sek.) durchschnittliche Wanduhrdauer (in Sekunden) der
Stressfaktor. Dies ist die gesamte Wanduhrzeit aller
Instanzen dieses bestimmten Stressors geteilt durch die
Anzahl dieser Stressoren, die ausgeführt werden.
Benutzerzeit (Sek.) Gesamtbenutzerzeit (in Sekunden), die für das Ausführen aller
Instanzen des Stressors.
Systemzeit (Sek.) Gesamtsystemzeit (in Sekunden), die beim Ausführen aller
Instanzen des Stressors.
Bogo ops/s (Echtzeit) Gesamtzahl der Bogo-Operationen pro Sekunde basierend auf der Ausführung der Wanduhr
Zeit. Die Wanduhrzeit spiegelt den scheinbaren Lauf wieder
Zeit. Je mehr Prozessoren man auf einem System hat, desto mehr
die Arbeitsbelastung kann auf diese verteilt werden und somit
die Wanduhrzeit verringert sich und die Bogo-Ops-Rate
wird steigen. Dies ist im Wesentlichen das "scheinbare" Bogo
Operationsrate des Systems.

bogo ops/s (usr+sys time) Gesamt bogo Operationen pro Sekunde basierend auf kumulativen
Benutzer- und Systemzeit. Dies ist die echte Bogo-Ops-Rate von
das System unter Berücksichtigung der Istzeit
Ausführungszeit des Stressors über alle
Prozessoren. Im Allgemeinen wird dies abnehmen, wenn man hinzufügt
mehr gleichzeitige Stressoren aufgrund von Konflikten im Cache,
Speicher, Ausführungseinheiten, Busse und E/A-Geräte.

--metriken-brief
Aktivieren Sie Metriken und geben Sie nur Metriken aus, die nicht Null sind.

--minimieren
überschreibt die Standard-Stressor-Einstellungen und setzt diese stattdessen auf das Minimum
Einstellungen erlaubt. Diese Voreinstellungen können immer vom jeweiligen Stressor überschrieben werden
Einstellungsmöglichkeiten bei Bedarf.

--keine-Beratung
ab Version 0.02.26 ruft stress-ng automatisch an verrückt(2) mit zufälligem Hinweis
Optionen vor jedem mmap und munmap, um das VM-Subsystem etwas stärker zu belasten.
Die Option --no-advise deaktiviert diese Standardeinstellung.

--page-in
Berühren Sie zugewiesene Seiten, die sich nicht im Kern befinden, und erzwingen Sie, dass sie wieder eingelagert werden
ist eine nützliche Option, um das Einblättern aller zugewiesenen Seiten zu erzwingen, wenn Sie das
bigheap-, mmap- und VM-Stressoren. Es wird die Leistung stark beeinträchtigen, wenn die
Speicher im System ist kleiner als die zugewiesenen Puffergrößen. Dies verwendet Mincore(2)
um die Seiten zu bestimmen, die nicht im Kern enthalten sind und daher berührt werden müssen, um sie zu pagen
zurück in.

--pathologisch
Stressoren aktivieren, von denen bekannt ist, dass sie Systeme hängen bleiben. Manche Stressoren können schnell
Ressourcen so verbrauchen, dass sie ein System schnell aufhängen können, bevor die
Kernel kann OOM sie töten. Diese Stressoren sind standardmäßig nicht aktiviert, diese Option
aktiviert sie, aber Sie möchten dies wahrscheinlich nicht. Du wurdest gewarnt.

--perf Messen Sie die Prozessor- und Systemaktivität mithilfe von Perf-Ereignissen. Nur Linux und Vorbehalt
Entleerer, nach perf_event_open(2): "Überprüfe deine Ergebnisse immer noch einmal! Verschiedene
verallgemeinerte Ereignisse hatten falsche Werte."

-Q, --ruhig
keine Ausgabe anzeigen.

-r N, --willkürlich N
Starte N zufällige Stressarbeiter. Wenn N 0 ist, dann ist die Anzahl der konfigurierten Prozessoren
wird für N verwendet.

--Sched Scheduler
Wählen Sie den benannten Scheduler aus (nur unter Linux). Um die Liste der verfügbaren Planer anzuzeigen
Verwenden Sie: stress-ng --sched which

--sched-prio prio
Wählen Sie die Prioritätsstufe des Schedulers (nur unter Linux). Wenn der Planer dies nicht tut
Wenn dies unterstützt wird, wird die Standardprioritätsstufe 0 gewählt.

--sequentiell N
Führen Sie nacheinander alle Stressoren nacheinander für eine Standardeinstellung von 60 Sekunden aus. Die
die Anzahl der zu startenden Instanzen jedes einzelnen Stressors ist N. Wenn N kleiner ist
als Null, dann wird die Anzahl der CPUs online für die Anzahl der Instanzen verwendet. Wenn
N ist null, dann wird die Anzahl der CPUs im System verwendet. Verwenden Sie die Option --timeout
um die Dauer für die Ausführung jedes Stressors anzugeben.

--syslog
log-Ausgabe (mit Ausnahme von ausführlichen -v-Nachrichten) an das Syslog.

--temp-Pfad Weg
einen Pfad für stress-ng temporäre Verzeichnisse und temporäre Dateien angeben; der Standard
path ist das aktuelle Arbeitsverzeichnis. Dieser Pfad muss Lese- und Schreibzugriff haben
für die stress-ng stressprozesse.

-t N, --Auszeit N
Stresstest nach N Sekunden beenden. Man kann auch die Zeiteinheiten in angeben
Sekunden, Minuten, Stunden, Tage oder Jahre mit dem Suffix s, m, h, d oder y.

--timer-slack N
Passen Sie den Zeitgeber-Slack pro Prozess auf N Nanosekunden an (nur Linux). Erhöhung der
Timer-Slack ermöglicht es dem Kernel, Timer-Ereignisse zusammenzuführen, indem er einige Unschärfen hinzufügt
Timer-Ablaufzeiten und reduzieren somit das Aufwachen. Umgekehrt verringern Sie den Timer
Slack erhöht das Aufwachen. Ein Wert von 0 für den Timer-Slack setzt das System
Standardwert von 50,000 Nanosekunden.

--mal
zeigen die kumulierten Benutzer- und Systemzeiten aller untergeordneten Prozesse am Ende von
der Stresslauf. Der Prozentsatz der Auslastung der verfügbaren CPU-Zeit beträgt auch
berechnet aus der Anzahl der Online-CPUs im System.

--tz sammeln Temperaturen aus den verfügbaren thermischen Zonen der Maschine (nur Linux).
Einige Geräte können eine oder mehrere thermische Zonen haben, andere keine.

-in, - ausführlich
alle Debug-, Warnungen und normale Informationsausgaben anzeigen.

--verifizieren
Überprüfen Sie die Ergebnisse, wenn ein Test ausgeführt wird. Dies ist nicht bei allen Tests verfügbar. Dieser Wille
Überprüfen Sie die Berechnungen oder den Speicherinhalt eines Testlaufs und berichten Sie an
stderr alle unerwarteten Fehler.

-V, --Version
Version zeigen.

-X, --ausschließen Liste
Geben Sie eine Liste mit einem oder mehreren auszuschließenden Stressoren an (dh führen Sie sie nicht aus).
Dies ist nützlich, um bestimmte Stressoren auszuschließen, wenn man viele Stressoren zum Ausführen auswählt
mit den Optionen --class, --sequential, --all und --random. Beispiel, laufen
die CPU-Klassen-Stressoren gleichzeitig und schließen die Numa- und Such-Stressoren aus:

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

-Y, - Yaml Dateinamen
Geben Sie gesammelte Statistiken in eine YAML-formatierte Datei namens 'Dateiname' aus.

Stressor spezifisch Optionen:

--Affinität N
Starten Sie N Worker, die die CPU-Affinität schnell ändern (nur unter Linux). Schnell wechseln
CPU-Affinität kann zu schlechtem Cache-Verhalten beitragen.

--affinity-ops N
Stoppen Sie Affinity-Worker nach N-Bogo-Affinitätsoperationen (nur unter Linux).

--affinity-rand
Wechseln Sie die CPU-Affinität nach dem Zufallsprinzip und nicht nach der Standardeinstellung sequentiell.

--af-alg N
Starte N Arbeiter, die die AF_ALG-Socket-Domäne ausüben, indem du verschiedene Größen hashst
zufällige Nachrichten mit SHA1, SHA224, SHA256, SHA384, SHA512, MD4, MD5, RMD128,
RMD160, RMD256, RMD320, WP256, WP384, WP512, TGR128, TGR160 und TGR192 Hashes.
(Nur Linux).

--af-alg-ops N
Stoppen Sie af-alg-Arbeiter, nachdem N AF_ALG-Nachrichten gehasht wurden.

--aio N
Starte N Worker, die mehrere kleine asynchrone E/A-Schreib- und Lesevorgänge auf a ausgeben
relativ kleine temporäre Datei über die POSIX aio-Schnittstelle. Das wird einfach treffen
den Dateisystem-Cache und verbrauchen viel Benutzer- und Kernelzeit bei der Ausgabe und
Bearbeitung von E/A-Anfragen. Standardmäßig verarbeitet jeder Worker-Prozess 16 gleichzeitige
I/O-Anfragen.

--aio-ops N
Stoppen Sie asynchrone POSIX-E/A-Worker nach N bogo asynchronen E/A-Anforderungen.

--aio-Anfragen N
Geben Sie die Anzahl der asynchronen POSIX-E/A-Anforderungen an, die jeder Worker ausgeben soll
Standard ist 16; 1 bis 4096 sind erlaubt.

--aiol N
Starten Sie N Worker, die mehrere 4K zufällige asynchrone E/A-Schreibvorgänge ausgeben, indem Sie die
Linux aio-Systemaufrufe io_setup(2) io_submit(2) io_getevents(2) und
io_destroy(2). Standardmäßig verarbeitet jeder Worker-Prozess 16 gleichzeitige E/A
Anfragen.

--aiol-ops N
Stoppen Sie asynchrone Linux-E/A-Worker nach N bogo asynchronen E/A-Anforderungen.

--aiol-requests N
Geben Sie die Anzahl der asynchronen Linux-E/A-Anforderungen an, die jeder Worker ausgeben soll
Standard ist 16; 1 bis 4096 sind erlaubt.

--apparmor N
Starten Sie N Arbeiter, die verschiedene Teile der AppArmor-Schnittstelle ausüben. Zur Zeit
man benötigt Root-Berechtigung, um diesen speziellen Test auszuführen. Dieser Test ist nur verfügbar
auf Linux-Systemen mit AppArmor-Unterstützung.

--apparmor-ops
Stoppen Sie die AppArmor-Arbeiter nach N Bogo-Operationen.

-B N, - Bigheap N
Starten Sie N Arbeiter, die ihre Heaps vergrößern, indem sie Speicher neu zuordnen. Wenn der Speicher aus ist
killer (OOM) unter Linux tötet den Worker oder die Zuweisung schlägt fehl, dann die Zuweisung
der Prozess beginnt von vorne. Beachten Sie, dass die OOM-Anpassung für den Arbeiter eingestellt ist
damit der OOM-Killer diese Arbeiter als erste Prozesskandidaten behandelt
töten.

--bigheap-ops N
Stoppen Sie die Big-Heap-Worker, nachdem N Bogo-Zuweisungsoperationen abgeschlossen sind.

--bigheap-Wachstum N
Geben Sie die Speichermenge an, um die der Heap pro Iteration vergrößert werden soll. Größe kann von 4K bis sein
64 MB. Der Standardwert ist 64 KB.

--bind-mount N
Starten Sie N Worker, die mount / an / innerhalb eines Benutzernamensraums wiederholt binden. Das kann
verbrauchen Ressourcen schnell und erzwingen Situationen, in denen der Speicher nicht mehr ausreichend ist. Benutze das nicht
Stressfaktor, es sei denn, Sie möchten riskieren, dass Ihre Maschine hängt.

--bind-mount-ops N
Stoppen Sie nach N Bind-Mount-Bogo-Operationen.

--brk N
Starten Sie N Worker, die das Datensegment mit mehreren Seiten um jeweils eine Seite vergrößern
brk(2) Anrufe. Jede erfolgreich zugewiesene neue Seite wird berührt, um sicherzustellen, dass sie es ist
im Gedächtnis resident. Wenn ein Speichermangel auftritt, wird der Test zurückgesetzt
das Datensegment bis zum Punkt vor dem Start und wiederholen Sie das Datensegment
die Größe noch einmal ändern. Der Prozess passt die Einstellung für nicht genügend Arbeitsspeicher so an, dass sie möglicherweise
durch den Out-of-Memory-Killer (OOM) vor anderen Prozessen getötet werden. Wenn es ist
vom OOM-Killer getötet, dann wird er automatisch durch eine Überwachung neu gestartet
Elternprozess.

--brk-ops N
Stoppen Sie die brk-Arbeiter nach N bogo brk-Operationen.

--brk-notouch
Berühren Sie nicht jede neu zugewiesene Datensegmentseite. Dies deaktiviert die Standardeinstellung von
das Berühren jeder neu zugewiesenen Seite und vermeidet somit den Kernel zwangsläufig
Sichern der Seite mit echtem physischen Speicher.

--bsuche N
Starten Sie N Arbeiter, die ein sortiertes Array von 32-Bit-Ganzzahlen binär durchsuchen, indem Sie verwenden
bsuchen(3). Standardmäßig enthält das Array 65536 Elemente. Dies ist ein nützliches
Methode, um einen wahlfreien Zugriff auf den Speicher und den Prozessor-Cache auszuüben.

--bsearch-ops N
Stoppen Sie den bsearch-Worker, nachdem N bogo bsearch-Operationen abgeschlossen sind.

--bSuchgröße N
spezifizieren Sie die Größe (Anzahl der 32-Bit-Ganzzahlen) im Array für bsearch. Größe kann sein
von 1K bis 4M.

-C N, --Zwischenspeicher N
Starte N Worker, die zufällige Wide-Spread-Memory-Lese- und -Schreibvorgänge zum Thrash ausführen
den CPU-Cache. Der Code bestimmt den CPU-Cache nicht intelligent
Konfiguration und daher möglicherweise suboptimal bei der Erzeugung von Hit-Miss-Lese-/Schreibvorgängen
Aktivität für einige Prozessoren.

--cache-zaun
Schreibserialisierung bei jedem Speichervorgang erzwingen (nur x86). Dies ist ein No-Op für
Nicht-x86-Architekturen.

--cache-flush
Erzwingen Sie das Leeren des Caches bei jeder Speicheroperation (nur x86). Dies ist ein No-Op für Nicht-x86
Architekturen.

- Cache-Ebene N
Geben Sie die auszuübende Cache-Ebene an (1=L1-Cache, 2=L2-Cache, 3=L3/LLC-Cache (der
Ursprünglich)). Wenn die Cache-Hierarchie nicht bestimmt werden kann, werden die integrierten Standardeinstellungen
.

--cache-no-affinity
Ändern Sie die Prozessoraffinität nicht, wenn --Zwischenspeicher ist in Kraft.

--cache-ops N
Stoppen Sie Cache-Thrash-Worker nach N Bogo-Cache-Thrash-Operationen.

--cache-prefetch
erzwinge Lesevorabruf bei der nächsten Leseadresse auf Architekturen, die Vorabrufen unterstützen.

--cache-wege N
Geben Sie die Anzahl der Cache-Möglichkeiten für das Training an. Dies ermöglicht eine Teilmenge der Gesamt
Cache-Größe, die ausgeübt werden soll.

--Deckel N
Starten Sie N Arbeiter, die pro Prozess Fähigkeiten lesen, über Aufrufe an kappt(2) (Linux
nur).

--cap-ops N
Stopp nach N-Cap-Bogo-Operationen.

--chdir N
Starten Sie N Arbeiter, die das Verzeichnis zwischen 8192 Verzeichnissen wechseln, indem Sie verwenden chdir(2).

--chdir-ops N
Stoppen Sie nach N chdir Bogo-Operationen.

--chmod N
Starten Sie N Worker, die die Dateimodus-Bits ändern über chmod(2) und fchmod(2) auf der
gleiche Datei. Je größer der Wert für N, desto mehr Konflikte in der einzelnen Datei.
Der Stressor arbeitet durch alle Kombinationen von Modusbits.

--chmod-ops N
Stopp nach N chmod bogo Operationen.

--Uhr N
Starten Sie N Arbeiter, die Uhren und POSIX-Timer trainieren. Für alle bekannten Uhrentypen dies
werde trainieren clock_getres(2) clock_gettime(2) und clock_nanosleep(2). Für alle
Bei bekannten Timern wird ein 50000ns-Timer erstellt und dieser so lange abgefragt, bis er abläuft.
Dieser Stressor führt zu häufigen Kontextwechseln.

--clock-ops N
Stoppuhr-Stressarbeiter nach N-Bogo-Operationen.

--Klon N
Starten Sie N Arbeiter, die Klone erstellen (über die klonen(2) Systemaufruf). Dieser Wille
Versuchen Sie schnell, einen Standard von 8192 Klonen zu erstellen, die sofort sterben und in einem warten
Zombie-Zustand, bis sie geerntet werden. Sobald die maximale Anzahl von Klonen erreicht ist
(oder Klon schlägt fehl, weil man das erlaubte Maximum erreicht hat) der älteste Klon
Thread geerntet und dann ein neuer Klon nach dem First-In-First-Out-Prinzip erstellt wird,
und dann wiederholt. Für jeden Klon wird ein zufälliges Klon-Flag ausgewählt, um es zu versuchen
verschiedene Klonoperationen ausüben. Der Klon-Stressor ist eine reine Linux-Option.

--clone-ops N
Stoppen Sie Klon-Stressarbeiter nach N-Bogo-Klon-Operationen.

--clone-max N
Versuchen Sie, bis zu N Klon-Threads zu erstellen. Dies kann möglicherweise nicht erreicht werden, wenn das System
Grenze ist kleiner als N.

--Kontext N
Starten Sie N Arbeiter, die drei Threads ausführen, die verwenden Kontext austauschen(3) um die zu implementieren
Kontextwechsel von Thread zu Thread. Dies übt ein schnelles Speichern von Prozesskontexten und
Wiederherstellung und ist bandbreitenbegrenzt durch Register- und Speichersicherungs- und Wiederherstellungsraten.

--context-ops N
Stoppen Sie N Kontextarbeiter nach N Bogo-Kontextwechseln. In diesem Stressor, 1 bogo op
entspricht 1000 swapcontext-Aufrufen.

--Datei kopieren N
Starte N Stressoren, die eine Datei unter Linux kopieren copy_file_range(2) Systemaufruf.
2 MB Datenblöcke werden von zufälligen Orten von einer Datei in eine zufällige kopiert
Speicherorte in eine Zieldatei. Standardmäßig sind die Dateien 256 MB groß. Daten sind
nach jedem mit dem Dateisystem synchronisiert copy_file_range(2) anrufen.

--copy-file-ops N
stoppen nach N copy_file_range() Aufrufen.

--copy-file-bytes N
Kopierdateigröße, der Standardwert ist 256 MB. Man kann die Größe in Einheiten von Bytes angeben,
KBytes, MBytes und GBytes mit dem Suffix b, k, m oder g.

-c N, --Zentralprozessor N
Starten Sie N Worker, die die CPU trainieren, indem Sie nacheinander alle
verschiedene CPU-Belastungsmethoden. Anstatt alle CPU-Belastungsmethoden auszuüben,
kann mit der Option --cpu-method eine bestimmte CPU-Belastungsmethode angeben.

--cpu-ops N
Stoppen Sie CPU-Stressarbeiter nach N-Bogo-Operationen.

-l P, --cpu-last P
Laden Sie die CPU mit P Prozent Auslastung für die CPU-Stressarbeiter. 0 ist effektiv a
Schlaf (keine Last) und 100 ist Vollladen. Die Ladeschleife wird in Compute unterteilt
Zeit (Last%) und Schlafzeit (100% - Last%). Genauigkeit ist abhängig von der Gesamtbelastung von
des Prozessors und der Reaktionsfähigkeit des Schedulers, so dass die tatsächliche Last möglicherweise
abweichend von der gewünschten Belastung. Beachten Sie, dass die Anzahl der Bogo-CPU-Operationen möglicherweise
nicht linear mit der Last skaliert werden, da einige Systeme CPU-Frequenzskalierung verwenden
und so führen höhere Lasten zu einer erhöhten CPU-Frequenz und einem größeren CPU-Bogo
Operationen.

--cpu-load-slice S
Hinweis - Diese Option ist nur nützlich, wenn --cpu-load weniger als 100 % beträgt. Die CPU-Last
ist in mehrere Besetzt- und Leerlaufzyklen unterteilt. Verwenden Sie diese Option, um die
Dauer einer belegten Zeitscheibe. Ein negativer Wert für S gibt die Anzahl der an
Iterationen, die ausgeführt werden sollen, bevor die CPU im Leerlauf läuft (z. B. -30 ruft 30 Iterationen einer CPU auf
Stressschleife). Ein Nullwert wählt eine zufällige Besetztzeit zwischen 0 und 0.5 Sekunden aus.
Ein positiver Wert für S gibt die Anzahl der Millisekunden vor dem Leerlauf an
der CPU (zB 100 hält die CPU für 0.1 Sekunden beschäftigt). Kleine Werte für angeben
S sorgt für kleine Zeitscheiben und eine reibungslosere Planung. --cpu-load als a . einstellen
relativ niedriger Wert und --cpu-load-slice groß zu sein, wird die CPU zwischen den Zyklen durchlaufen
lange Leerlauf- und Auslastungszyklen und trainieren unterschiedliche CPU-Frequenzen. Die Therme
CPU-Reichweite wird ebenfalls getaktet, daher ist dies ein guter Mechanismus, um die
Scheduler, Frequenzskalierung und passive/aktive thermische Kühlmechanismen.

--cpu-Methode Methode
Geben Sie eine CPU-Belastungsmethode an. Standardmäßig werden alle Stressmethoden ausgeübt
sequentiell, man kann jedoch bei Bedarf nur eine Methode angeben, die verwendet werden soll.
Die verfügbaren CPU-Stress-Methoden werden wie folgt beschrieben:

Methodik Beschreibung
alle iterieren über alle unten aufgeführten CPU-Stress-Methoden
ackermann Ackermann-Funktion: berechne A(3, 10), wobei:
A(m, n) = n + 1 wenn m = 0;
A(m – 1, 1) wenn m > 0 und n = 0;
A(m - 1, A(m, n - 1)) wenn m > 0 und n > 0
bitops verschiedene Bitoperationen von bithack, nämlich: reverse bits, parity
check, bit count, runden auf die nächste Potenz von 2
callfunc ruft rekursiv 8 Argument C-Funktion bis zu einer Tiefe von 1024 Aufrufen auf
und entspannen Sie sich
cfloat 1000 Iterationen einer Mischung aus komplexen Gleitkommaoperationen
cdouble 1000 Iterationen einer Mischung aus doppelten Gleitkommakomplexen
Geschäftstätigkeit
clongdouble 1000 Iterationen einer Mischung aus langen doppelten Gleitkommakomplexen
Geschäftstätigkeit
korrelieren eine 16384 × 1024-Korrelation von zufälligen Doppeln durchführen
crc16 berechnet 1024 Runden CCITT CRC16 auf Zufallsdaten
dezimal32 1000 Iterationen einer Mischung aus 32-Bit-Dezimal-Gleitkomma
Operationen (nur GCC)
dezimal64 1000 Iterationen einer Mischung aus 64-Bit-Dezimal-Gleitkomma
Operationen (nur GCC)
dezimal128 1000 Iterationen einer Mischung aus 128-Bit-Dezimal-Gleitkomma
Operationen (nur GCC)
Dither Floyd-Steinberg-Dithering eines 1024 × 768 Zufallsbildes aus 8 Bit
bis auf 1 Bit Tiefe.
djb2a 128 Runden Hash DJB2a (Dan Bernstein Hash mit dem xor
Variante) auf 128 bis 1 Byte zufälliger Strings
doppelte 1000 Iterationen einer Mischung aus Gleitkommazahlen mit doppelter Genauigkeit
Geschäftstätigkeit
euler berechne e mit n = (1 + (1 ÷ n)) ↑ n
explog iterieren auf n = exp(log(n) ÷ 1.00002)
Fibonacci berechnen Fibonacci-Folge von 0, 1, 1, 2, 5, 8...
fft 4096 Sample Fast Fourier Transform
float 1000 Iterationen einer Mischung aus Gleitkommaoperationen
fnv1a 128 Runden Hash FNV-1a (Fowler–Noll–Vo Hash mit dem xor then
Multiplikationsvariante) auf 128 bis 1 Byte zufälliger Zeichenfolgen
gamma berechne die Euler-Mascheroni-Konstante γ unter Verwendung der Begrenzung
Differenz zwischen den harmonischen Reihen (1 + 1/2 + 1/3 + 1/4 + 1/5
... + 1/n) und den natürlichen Logarithmus ln(n) für n = 80000.
gcd berechne GCD von ganzen Zahlen
Gray berechnen Binärcode zu Graycode und Graycode zurück zu Binärcode für
ganze Zahlen von 0 bis 65535
Hamming berechnet Hamming-H(8,4)-Codes auf 262144 Chargen von 4-Bit-Daten. Dies
wandelt 4-Bit-Daten in 8-Bit-Hamming-Code um, der 4 Paritätsbits enthält.
Für die Datenbits d1..d4 werden Paritätsbits wie folgt berechnet:
p1 = d2 + d3 + d4
p2 = d1 + d3 + d4
p3 = d1 + d2 + d4
p4 = d1 + d2 + d3
Hanoi lösen einen Stapel von 21 Disc Towers of Hanoi mit der rekursiven Lösung
hyperbolisch berechnen sinh(θ) × cosh(θ) + sinh(2θ) + cosh(3θ) für float, double
und lange doppelte hyperbolische Sinus- und Cosinusfunktionen mit θ = 0
auf 2π in 1500 Schritten
idct 8 × 8 IDCT (Inverse diskrete Kosinustransformation)
int8 1000 Iterationen einer Mischung aus 8-Bit-Integer-Operationen
int16 1000 Iterationen einer Mischung aus 16-Bit-Integer-Operationen
int32 1000 Iterationen einer Mischung aus 32-Bit-Integer-Operationen
int64 1000 Iterationen einer Mischung aus 64-Bit-Integer-Operationen

int128 1000 Iterationen einer Mischung aus 128-Bit-Integer-Operationen (nur GCC)
int32float 1000 Iterationen einer Mischung aus 32-Bit-Integer und Gleitkomma
Geschäftstätigkeit
int32double 1000 Iterationen einer Mischung aus 32-Bit-Integer und doppelter Genauigkeit
Gleitkommaoperationen
int32longdouble 1000 Iterationen einer Mischung aus 32-Bit-Integer und Long-Double
Präzisions-Gleitkomma-Operationen
int64float 1000 Iterationen einer Mischung aus 64-Bit-Integer und Gleitkomma
Geschäftstätigkeit
int64double 1000 Iterationen einer Mischung aus 64-Bit-Integer und doppelter Genauigkeit
Gleitkommaoperationen
int64longdouble 1000 Iterationen einer Mischung aus 64-Bit-Integer und Long-Double
Präzisions-Gleitkomma-Operationen
int128float 1000 Iterationen einer Mischung aus 128-Bit-Integer und Gleitkomma
Operationen (nur GCC)
int128double 1000 Iterationen einer Mischung aus 128-Bit-Integer und doppelter Genauigkeit
Gleitkommaoperationen (nur GCC)
int128longdouble 1000 Iterationen einer Mischung aus 128-Bit-Integer und Long-Double
Präzisions-Gleitkommaoperationen (nur GCC)
int128decimal32 1000 Iterationen einer Mischung aus 128-Bit-Integer und 32-Bit-Dezimal
Gleitkommaoperationen (nur GCC)
int128decimal64 1000 Iterationen einer Mischung aus 128-Bit-Integer und 64-Bit-Dezimal
Gleitkommaoperationen (nur GCC)
int128decimal128 1000 Iterationen einer Mischung aus 128-Bit-Integer und 128-Bit-Dezimal
Gleitkommaoperationen (nur GCC)
jenkin Jenkins Integer-Hash auf 128 Runden von 128..1 Byte Zufallsdaten
jmp Einfacher nicht optimierter Vergleich >, <, == und jmp-Verzweigung
ln2 berechnen ln(2) basierend auf Serien:
1 - 1/2 + 1/3 - 1/4 + 1/5 - 1/6 ...
longdouble 1000 Iterationen einer Mischung aus langen Gleitkommazahlen mit doppelter Genauigkeit
Geschäftstätigkeit
Schleife einfache leere Schleife
matrixprod Matrixprodukt von zwei 128 × 128-Matrizen von doppelten Gleitkommazahlen. Testen
auf 64-Bit-x86-Hardware zeigt, dass dies eine gute Mischung aus
Speicher-, Cache- und Gleitkommaoperationen und ist wahrscheinlich die
beste CPU-Methode, um eine CPU heiß laufen zu lassen.
nsqrt berechne sqrt() von langen Doubles mit Newton-Raphson
omega berechne die durch Ωe↑Ω = 1 definierte omega-Konstante unter Verwendung von effizient
Iteration von Ωn+1 = (1 + Ωn) / (1 + e↑Ωn)
Parity Parität berechnen mit verschiedenen Methoden aus dem Standford Bit
Knifflige Hacks. Die angewandten Methoden sind: der naive Weg, der naive
wie mit der Brian Kernigan Bit-Counting-Optimierung, die
Multiplikationsweg, Parallelweg und Nachschlagetabellenweg (2
Variationen).
phi berechnet den Goldenen Schnitt ϕ mit Hilfe von Reihen
pi berechnen π mit dem Srinivasa Ramanujan Fast Convergence Algorithmus
pjw 128 Runden Hash pjw Funktion auf 128 bis 1 Byte Zufall
Streicher
prime Finde alle Primzahlen im Bereich 1..1000000 mit einem leicht
optimierte Brute-Force-Naive Trial Division Suche
psi berechnen ψ (die reziproke Fibonacci-Konstante) unter Verwendung der Summe der
Kehrwerte der Fibonacci-Zahlen
Damen berechnen alle Lösungen des klassischen 8 Damen Problems für
Boardgrößen 1..12
rand 16384 Iterationen von rand(), wobei rand der MWC-Pseudozufall ist
Zahlengenerator. Die MWC-Zufallsfunktion verkettet zwei 16-Bit
Multiply-with-Carry-Generatoren:
x(n) = 36969 × x(n - 1) + Übertrag,
y(n) = 18000 × y(n - 1) + Übertrag mod 2 ↑ 16

und hat eine Periode von etwa 2 ↑ 60
rand48 16384 Iterationen von drand48(3) und land48(3)
rgb konvertiert RGB in YUV und zurück in RGB (CCIR 601)
sdbm 128 Runden Hash sdbm (wie in der SDBM-Datenbank und GNU awk verwendet)
auf 128 bis 1 Byte zufälliger Zeichenfolgen
finden Sie die Primzahlen im Bereich 1..10000000 mit dem Sieb von
Eratosthenes
sqrt berechnen sqrt(rand()), wobei rand die MWC-Pseudozufallszahl ist
Generator

trig berechne sin(θ) × cos(θ) + sin(2θ) + cos(3θ) für float, double und
lange Doppelsinus- und Cosinusfunktionen mit θ = 0 bis 2π in 1500
Schritte
union führt Integer-Arithmetik für eine Mischung von Bitfeldern in einer C-Union durch.
Dies übt, wie gut der Compiler und die CPU ganze Zahlen ausführen können
Bitfeld lädt und speichert.
zeta berechnen die Riemann-Zeta-Funktion ζ(s) für s = 2.0..10.0

Beachten Sie, dass einige dieser Methoden versuchen, die CPU mit Berechnungen zu trainieren, die in
einige Anwendungsfälle aus der realen Welt. Der Code wurde jedoch nicht auf eine bestimmte Weise optimiert.
Architekturbasis, kann daher im Vergleich zu handoptimiertem Code, der in verwendet wird, suboptimal sein
einige Anwendungen. Sie versuchen, die typischen Anweisungsmischungen darzustellen, die in gefunden werden
diese Anwendungsfälle.

--cpu-online N
Starten Sie N Worker, die zufällig ausgewählte CPUs offline und online schalten. Nur dieses Linux
stressor benötigt Root-Rechte, um diese Aktion auszuführen.

--cpu-online-ops N
Stoppen Sie nach Offline-/Online-Operationen.

--Krypta N
Starte N Arbeiter, die ein zufälliges Passwort mit 16 Zeichen verschlüsseln mit Krypta(3). Das
Das Passwort wird mit den Verschlüsselungsmethoden MD5, SHA-256 und SHA-512 verschlüsselt.

--crypt-ops N
Stoppen Sie nach N bogo-Verschlüsselungsvorgängen.

--dämon N
Starte N Arbeiter, die jeweils einen Daemon erstellen, der sofort nach dem Erstellen stirbt
ein anderer Dämon und so weiter. Dies funktioniert effektiv durch die Prozesstabelle mit
kurzlebige Prozesse, die keinen Parent haben und auf die von init gewartet wird. Dies
übt init Druck aus, schnell Kinder zu ernten. Die Daemon-Prozesse führen die
übliche Mischung von Aufrufen, um sich in typische UNIX-Daemons zu verwandeln, also imitiert dies künstlich
sehr starker Stress des Dämonensystems.

--daemon-ops N
Stoppen Sie Daemon-Worker, nachdem N Daemons erstellt wurden.

-D N, - Dentry N
Starten Sie N Arbeiter, die Verzeichniseinträge erstellen und entfernen. Dies sollte eine Datei erstellen
Systemmetadatenaktivität. Die Namen der Verzeichniseinträge sind mit einem Gray-Code versehen
codierte Zahl, um zu versuchen, das Hashing des Namensraums zu verwechseln.

--dentry-ops N
Stoppen Sie Denty Thrash Arbeiter nach N Bogo Dentry Operationen.

--dentry-order [ | rückgängig machen | Schritt | zufällig ]
Geben Sie die Reihenfolge der Verknüpfungen von Dentries an, kann vorwärts, rückwärts, schritt oder zufällig sein.
Standardmäßig werden die Verknüpfungen in zufälliger Reihenfolge aufgehoben. Die Verlinkung der Weiterleitung wird aufgehoben
sie vom ersten zum letzten, umgekehrte Reihenfolge trennt sie vom letzten zum ersten, Schritt
Die Reihenfolge wird sie entkoppeln, indem sie in einem quasi-zufälligen Muster um die Reihenfolge herumgeht und
zufällige Reihenfolge wählt zufällig eine von Vorwärts-, Rückwärts- oder Schrittreihenfolge aus.

--Zähne N
Erstellen Sie N Dentries pro Dentry-Thrashing-Schleife, der Standardwert ist 2048.

--dir N
Starten Sie N Arbeiter, die Verzeichnisse mit mkdir und rmdir erstellen und entfernen.

--dir-ops N
Stoppen Sie Verzeichnis-Thrash-Worker nach N bogo-Verzeichnisoperationen.

- dup N
Starte N Arbeiter die Leistung bringen dup(2) und dann schließen(2) Operationen auf /dev/zero. Die
Die maximale Anzahl gleichzeitiger Öffnungen ist systemdefiniert, daher wird der Test bis zu diesem Punkt ausgeführt
Maximum oder 65536 offene Dateideskriptoren, je nachdem, was zuerst eintritt.

--dup-ops N
Stoppen Sie die Dup-Stressarbeiter nach N-Bogo-Open-Operationen.

--epoll N
Beginnen Sie mit N Arbeitern, die verschiedene verwandte Socket-Stress-Aktivitäten ausführen, indem Sie
epoll_wait(2) um neue Verbindungen zu überwachen und zu handhaben. Dies betrifft Client/Server
Prozesse, die schnelles Verbinden, Senden/Empfangen und Trennen auf der lokalen Seite ausführen
Gastgeber. Die Verwendung von epoll ermöglicht die effiziente Abwicklung einer großen Anzahl von Verbindungen,
dies kann jedoch dazu führen, dass sich die Verbindungstabelle füllt und weiter blockiert
Socket-Verbindungen, was sich auf die epoll bogo op Stats auswirkt. Für IPv4 und IPv6
Domänen werden mehrere Server auf mehreren Ports gespawnt. Der E-Poll-Stressor ist für
Nur Linux.

--epoll-domain D
Geben Sie die zu verwendende Domäne an, der Standardwert ist Unix (auch bekannt als lokal). Derzeit IPv4, IPv6
und Unix werden unterstützt.

--epoll-port P
Beginnen Sie am Socket-Port P. Für N epoll-Worker-Prozesse sind die Ports P bis (P * 4) - 1
für IPv4 verwendet, IPv6-Domänen und Ports P bis P - 1 werden für die Unix-Domäne verwendet.

--epoll-ops N
Stoppen Sie epoll-Arbeiter nach N-Bogo-Operationen.

--eventfd N
N Parent- und Child-Worker-Prozesse starten, die 8-Byte-Ereignisnachrichten lesen und schreiben
zwischen ihnen über den eventfd-Mechanismus (nur Linux).

--eventfd-ops N
Eventfd-Arbeiter nach N-Bogo-Operationen stoppen.

--exec N
Beginnen Sie mit N Arbeitern, die ständig Kinder abspalten, die Stress ausüben, und dann aussteigen
fast sofort.

--exec-ops N
Stoppen Sie leitende Stressarbeiter nach N-Bogo-Operationen.

--exec-max P
Erstellen Sie P untergeordnete Prozesse, die Stress-ng ausführen, und warten Sie dann, bis sie beendet werden
Wiederholung. Der Standardwert ist nur 1; höhere Werte erzeugen viele temporäre Zombies
Prozesse, die darauf warten, geerntet zu werden. Man kann den Prozess möglicherweise füllen
Tabelle mit hohen Werten für --exec-max und --exec.

-F N, --fallocate N
Beginnen Sie mit der kontinuierlichen Fallocation von N Workern (Vorabzuweisung von Dateispeicherplatz) und der Funcierung
(Dateikürzung) temporäre Dateien. Wenn die Datei größer als der freie Speicherplatz ist,
fallocate erzeugt einen ENOSPC-Fehler, der von diesem Stressor ignoriert wird.

--fallocate-bytes N
zugewiesene Dateigröße ist der Standardwert 1 GB. Man kann die Größe in Einheiten von angeben
Bytes, KBytes, MBytes und GBytes mit dem Suffix b, k, m oder g.

--fallocate-ops N
Stoppen Sie Fallocate-Stressarbeiter nach N-Bogo-Fallocate-Operationen.

--Fehler N
Starte N Arbeiter, die kleinere und größere Seitenfehler erzeugen.

--Fehler-Ops N
Stoppen Sie die Seitenfehlerarbeiter nach N Bogo-Seitenfehleroperationen.

--fcntl N
Starte N Arbeiter die Leistung bringen fktl(2) Anrufe mit verschiedenen Befehlen. Die ausgeübte
Befehle (sofern verfügbar) sind: 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 und F_SETSIG.

--fcntl-ops N
Stoppen Sie die fcntl-Arbeiter nach N bogo fcntl-Operationen.

--fiemap N
Starte N Worker, die jeweils eine Datei mit vielen sich zufällig ändernden Extents erstellen und haben
4 untergeordnete Prozesse pro Arbeiter, die die Umfangsinformationen mithilfe der
FS_IOC_FIEMAP ioctls(2).

--fiemap-ops N
Stoppen Sie nach N fiemap-bogo-Operationen.

--fiemap-Größe N
Geben Sie die Größe der fiemap'd-Datei in Bytes an. Man kann die Größe in Einheiten angeben
von Bytes, KBytes, MBytes und GBytes mit dem Suffix b, k, m oder g. Größere Dateien
enthält mehr Ausdehnungen, was beim Sammeln von Ausdehnungsinformationen zu mehr Stress führt.

--fifo N
Starten Sie N Worker, die eine Named Pipe ausüben, indem sie 64-Bit-Ganzzahlen übertragen.

--fifo-ops N
Stoppen Sie Fifo-Worker nach N Bogo-Pipe-Schreiboperationen.

--fifo-leser N
Erstellen Sie für jeden Worker N fifo-Reader-Worker, die die Named Pipe mit Simple . lesen
Blockieren von Lesevorgängen.

--Dateiname N
Starten Sie N Arbeiter, die die Dateierstellung mit Dateinamen unterschiedlicher Länge durchführen
enthält eine Reihe von zulässigen Dateinamenzeichen. Dies wird versuchen zu sehen, ob es möglich ist
Überschreiten Sie die zulässige Dateinamenlänge des Dateisystems, testen Sie verschiedene Dateinamen
Längen zwischen 1 und der vom Dateisystem maximal zulässigen Länge.

--Dateiname-ops N
Stoppen Sie Dateinamen-Worker nach N bogo Dateinamen-Tests.

--filename-opts wählen
Verwenden Sie Zeichen im Dateinamen basierend auf der Option 'opt'. Gültige Optionen sind:

Option Beschreibung
Probe-Standardoption, das Dateisystem auf gültige zulässige Zeichen untersuchen
in einem Dateinamen und verwenden Sie diese
posix verwendet Zeichen wie in den Open Group Base Specifications angegeben
Ausgabe 7, POSIX.1-2008, 3.278 Zeichensatz für tragbare Dateinamen
ext verwendet Zeichen, die von den Dateisystemen ext2, ext3, ext4 erlaubt sind,
nämlich jedes 8-Bit-Zeichen außer NUL und /

--Herde N
Starten Sie N Arbeiter, die eine einzelne Datei sperren.

--flock-ops N
Stoppen Sie Flockstressarbeiter nach N-Bogo-Flock-Operationen.

-f N, --Gabel N
Beginnen Sie mit N Arbeitern, die ständig Kinder abzweigen, die sofort aussteigen.

--fork-ops N
Stoppen Sie Gabelstressarbeiter nach N-Bogo-Operationen.

--gabel-max P
P untergeordnete Prozesse erstellen und dann warten, bis sie pro Iteration beendet werden. Der Standard
ist nur 1; höhere Werte erzeugen viele temporäre Zombie-Prozesse, die
warten darauf, geerntet zu werden. Man kann potentiell die Prozesstabelle mit high füllen
Werte für --fork-max und --fork.

--fp-Fehler N
Starte N Worker, die Gleitkommaausnahmen generieren. Berechnungen werden durchgeführt
um FE_DIVBYZERO, FE_INEXACT, FE_INVALID, FE_OVERFLOW und . zu erzwingen und zu prüfen
FE_UNDERFLOW-Ausnahmen. EDOM- und ERANGE-Fehler werden ebenfalls geprüft.

--fp-error-ops N
Stoppen Sie nach N Bogo-Gleitkommaausnahmen.

--fstat N
starte N Arbeiter fstat'ing Dateien in einem Verzeichnis (Standard ist / dev).

--fstat-ops N
Stoppen Sie fstat-Stressarbeiter nach N bogo fstat-Operationen.

--fstat-dir Verzeichnis
Geben Sie das Verzeichnis für fstat an, um die Standardeinstellung von /dev zu überschreiben. Alle Dateien in
das Verzeichnis wird wiederholt fstat'd.

--futex N
Starten Sie N Arbeiter, die den futex-Systemaufruf schnell ausführen. Jeder Arbeiter hat zwei
Prozesse, einen futex-Kellner und einen futex-wecker. Der Kellner wartet mit einem sehr kleinen
timeout, um das Timeout und das schnelle Warten auf abgefragte futex zu betonen. Dies ist ein Linux
spezielle Stressoption.

--futex-ops N
Stoppen Sie futex-Arbeiter nach N bogo erfolgreichen futex-Warteoperationen.

--erhalten N
Starte N Worker, die alle get*(2)-Systemaufrufe aufrufen.

--get-ops N
Stoppen Sie, Arbeiter zu bekommen, nachdem N bogo get-Operationen erhalten hat.

--getdent N
Starte N Arbeiter, die Verzeichnisse rekursiv lesen / proc, / Dev /, / Tmp, / sys und /Lauf
mit getdents und getdents64 (nur Linux).

--getdent-ops N
stoppen Sie getdent-Mitarbeiter nach N bogo getdent bogo-Operationen.

--getrandom N
Starten Sie N Arbeiter, die 8192 zufällige Bytes aus dem /dev/urandom-Pool erhalten, indem Sie die
zufällig(2) Systemaufruf (nur Linux).

--getrandom-ops N
stoppen Sie getrandom Arbeiter nach N bogo get Operationen.

--handhaben N
starten Sie N Arbeiter, die die name_to_handle_at(2) und open_by_handle_at(2)
Systemaufrufe. (Nur Linux).

--handle-ops N
Stoppen Sie nach N-Handle-Bogo-Operationen.

-d N, --Festplatte N
Starten Sie N Arbeiter, die ständig temporäre Dateien schreiben, lesen und entfernen.

--hdd-bytes N
N Bytes für jeden HDD-Prozess schreiben, der Standardwert ist 1 GB. Man kann die Größe angeben
in Einheiten von Bytes, KBytes, MBytes und GBytes mit dem Suffix b, k, m oder g.

--hdd-opts Liste
Geben Sie verschiedene Stresstest-Optionen als kommagetrennte Liste an. Optionen sind wie
folgt:

Option Beschreibung
Versuchen Sie direkt, Cache-Effekte der E/A zu minimieren. Datei-I/O-Schreibvorgänge sind
direkt aus User-Space-Puffer und synchron ausgeführt
Es wird auch versucht, zu übertragen. Um synchrone E/A zu gewährleisten, auch
Verwenden Sie die Synchronisierungsoption.
dsync sicherstellen, dass die Ausgabe auf die zugrunde liegende Hardware und Datei übertragen wurde
Metadaten wurden aktualisiert (unter Verwendung des O_DSYNC-Open-Flags). Das ist
äquivalent zu jedem schreiben(2) gefolgt von einem Aufruf an
fdatasync(2). Siehe auch die Option fdatasync.
fadv-dontneed weist den Kernel an, damit zu rechnen, dass auf die Daten in nächster Zeit nicht zugegriffen wird
Zukunft.
fadv-noreuse weist den Kernel an, nur einmal auf die Daten zuzugreifen.
fadv-normal Advise Kernel gibt es kein explizites Zugriffsmuster für die Daten.
Dies ist die Annahme der Standardberatung.
fadv-rnd weist den Kernel an, wahlfreie Zugriffsmuster für die Daten zu erwarten.
fadv-seq weist den Kernel an, sequenzielle Zugriffsmuster für die Daten zu erwarten.
fadv-willneed weist den Kernel an, damit zu rechnen, dass auf die Daten in naher Zukunft zugegriffen wird
Zukunft.

fsync löscht alle geänderten In-Core-Daten nach jedem Schreibvorgang in die Ausgabe
Gerät mit einem expliziten fsync(2) anrufen.
fdatasync ähnlich wie fsync, aber leeren Sie die geänderten Metadaten nicht, es sei denn
Metadaten sind erforderlich, damit spätere Datenlesevorgänge korrekt verarbeitet werden.
Dies verwendet ein explizites fdatasync(2) anrufen.
iovec verwendet Readv/Writev-Mehrfachpuffer-I/Os anstelle von Read/Write.
Anstelle von 1 Lese-/Schreibvorgang wird der Puffer in eine
iovec von 16 Puffern.
noatime aktualisiert den Zeitstempel des letzten Zugriffs der Datei nicht, dies kann dies reduzieren
Metadaten schreibt.
sync sicherstellen, dass die Ausgabe an die zugrunde liegende Hardware übertragen wurde (mit
das O_SYNC-Öffnen-Flag). Dies entspricht einem jeden schreiben(2) sein
gefolgt von einem Anruf an fsync(2). Siehe auch die fsync-Option.
rd-rnd Daten nach dem Zufallsprinzip lesen. Geschriebene Daten werden standardmäßig nicht zurückgelesen,
Diese Option erzwingt jedoch ein zufälliges Zurücklesen.
rd-seq liest Daten sequentiell. Geschriebene Daten werden standardmäßig nicht zurückgelesen,
diese Option erzwingt jedoch ein sequentielles Zurücklesen.
syncfs schreibt alle gepufferten Änderungen von Dateimetadaten und -daten auf die
Dateisystem, das die HDD-Worker-Dateien enthält.
utimes erzwingt die Aktualisierung des Dateizeitstempels, was das Schreiben von Metadaten erhöhen kann.
wr-rnd Daten nach dem Zufallsprinzip schreiben. Die Option wr-seq kann nicht gleichzeitig verwendet werden
Zeit.
wr-seq schreibt Daten sequentiell. Dies ist die Standardeinstellung, wenn keine Schreibmodi vorhanden sind
spezifiziert.

Beachten Sie, dass sich einige dieser Optionen gegenseitig ausschließen, zum Beispiel kann es nur eine geben
Schreib- oder Lesemethode. Außerdem können sich Fadvise-Flags gegenseitig ausschließen, zum Beispiel
fadv-willneed kann nicht mit fadv-dontneed verwendet werden.

--hdd-ops N
Stoppen Sie HDD-Stressarbeiter nach N-Bogo-Operationen.

--hdd-write-size N
Geben Sie die Größe jedes Schreibvorgangs in Byte an. Die Größe kann von 1 Byte bis 4 MB betragen.

--Haufensortierung N
Starten Sie N Arbeiter, die 32-Bit-Ganzzahlen mit dem BSD-Heapsort sortieren.

--heapsort-ops N
Stoppen Sie Heapsort-Stressarbeiter nach N Bogo-Haufen.

--heapsort-size N
Geben Sie die Anzahl der zu sortierenden 32-Bit-Ganzzahlen an, der Standardwert ist 262144 (256 × 1024).

--hsuchen N
Starten Sie N Worker, die eine 80 % volle Hash-Tabelle durchsuchen, indem Sie verwenden hsuchen(3). Standardmäßig,
Es werden 8192 Elemente in die Hash-Tabelle eingefügt. Dies ist eine nützliche Methode, um
Üben Sie den Zugriff auf den Speicher und den Prozessor-Cache aus.

--hsearch-ops N
stoppen Sie die hsearch-Arbeiter, nachdem N bogo hsearch-Operationen abgeschlossen sind.

--hsearch-size N
Geben Sie die Anzahl der Hash-Einträge an, die in die Hash-Tabelle eingefügt werden sollen. Größe kann sein
von 1K bis 4M.

--icache N
Starten Sie N Worker, die den Instruktions-Cache belasten, indem Sie den Instruktions-Cache erzwingen
lädt nach. Dies wird erreicht, indem eine Befehls-Cache-Zeile modifiziert wird, wodurch die
Prozessor, um es neu zu laden, wenn wir eine darin enthaltene Funktion aufrufen. Aktuell nur
verifiziert und aktiviert für Intel x86-CPUs.

--icache-ops N
Stoppen Sie die ICache-Worker, nachdem N Bogo-ICache-Operationen abgeschlossen sind.

--notify N
Starten Sie N Arbeiter, die Dateisystemaktivitäten wie Erstellen/Löschen ausführen
Dateien/Verzeichnisse, Verschieben von Dateien usw., um die verschiedenen Innotify-Ereignisse zu betonen
(Nur Linux).

--notify-ops N
Stoppen Sie innotify-Stressarbeiter nach N inotify-Bogo-Operationen.

-i N, --io N
Starte N Arbeiter, die ständig anrufen synchronisieren(2) Puffer-Cache auf die Festplatte zu übertragen. Dies
kann in Verbindung mit den Optionen --hdd verwendet werden.

--io-ops N
Stoppen Sie io-Stressarbeiter nach N-Bogo-Operationen.

--timer N
Starten Sie N Arbeiter, die die Systemintervall-Timer ausüben. Dies richtet ein
ITIMER_PROF-Timer, der ein SIGPROF-Signal erzeugt. Die Standardfrequenz für die
itimer ist 1 MHz, der Linux-Kernel wird dies jedoch so einstellen, dass dies nicht mehr ist
schnelle Einstellung, daher sind hochfrequente SIGPROF-Signale normalerweise nicht möglich. EIN
Busy Loop dreht sich an getitimer(2) Aufrufe, um CPU zu verbrauchen und daher den itimer zu dekrementieren
basierend auf der Zeit, die in CPU und Systemzeit aufgewendet wird.

--timer-ops N
Stoppen Sie itimer-Stressarbeiter nach N bogo itimer SIGPROF-Signalen.

--timer-freq F
lassen Sie den Timer bei F Hz laufen; Bereich von 1 bis 1000000 Hz. Normalerweise ist die höchste Frequenz
begrenzt durch die Anzahl der ruckartigen Ticks pro Sekunde, also über 1000 Hz zu laufen ist
in der Praxis schwer zu erreichen.

--kcmp N
Starten Sie N Arbeiter, die verwenden kcmp(2) um Eltern- und Kindprozesse zu vergleichen, um zu bestimmen
wenn sie Kernel-Ressourcen teilen (nur Linux).

--kcmp-ops N
Stoppen Sie kcmp-Arbeiter nach N bogo kcmp-Operationen.

--Schlüssel N
Starten Sie N Arbeiter, die Schlüssel erstellen und manipulieren mit add_key(2) und Kektl(2). Wie
viele Schlüssel werden erstellt, wie es das Limit pro Benutzer zulässt und dann der folgende keyctl
Befehle werden auf jeder Taste ausgeführt: KEYCTL_SET_TIMEOUT, KEYCTL_DESCRIBE,
KEYCTL_UPDATE, KEYCTL_READ, KEYCTL_CLEAR und KEYCTL_INVALIDATE.

--key-ops N
stoppen Sie Schlüsselarbeiter nach N bogo Schlüsseloperationen.

--töten N
Starten Sie N Arbeiter, die SIGUSR1-Kill-Signale an einen SIG_IGN-Signalhandler senden. Die meisten von
die Prozesszeit landet im Kernel-Space.

--kill-ops N
Stoppen Sie die Tötung von Arbeitern nach N-Bogo-Tötungsoperationen.

--klog N
Starte N Arbeiter, die den Kernel trainieren syslog(2) Systemaufruf. Dies wird versuchen,
Lesen Sie das Kernel-Log mit unterschiedlich großen Lesepuffern. Nur Linux.

--klog-ops N
Stoppen Sie klog-Worker nach N Syslog-Operationen.

--mieten N
Starten Sie N Arbeiter, die Mietverträge über die fktl(2) F_SETLEASE
Betrieb. Die übergeordneten Prozesse sperren und entsperren kontinuierlich einen Lease für eine Datei, während
eine vom Benutzer wählbare Anzahl von untergeordneten Prozessen öffnet die Datei mit einem nicht blockierenden Öffnen
um SIGIO Mietvertragsabbruchbenachrichtigungen an die Eltern zu generieren. Dieser Stressor ist
nur verfügbar, wenn F_SETLEASE, F_WRLCK und F_UNLCK Unterstützung bereitgestellt wird von fktl(2).

--lease-ops N
Stoppen Sie Mietarbeiter nach N-Bogo-Operationen.

--Lease-Breaker N
Starte N untergeordnete Lease-Breaker-Prozesse pro Lease-Worker. Normalerweise ist ein Kind
viel, um viele SIGIO-Benachrichtigungssignale für die Mietunterbrechung an die Eltern zu erzwingen,
Mit dieser Option können Sie jedoch bei Bedarf weitere untergeordnete Prozesse angeben.

--Verknüpfung N
Starten Sie N Arbeiter, die Hardlinks erstellen und entfernen.

--link-ops N
Stoppen Sie Link-Stress-Arbeiter nach N-Bogo-Operationen.

--lockbus N
Starte N Worker, die 64 Byte zufällig ausgewählten Speichers schnell sperren und inkrementieren
aus einer 16-MB-mmap-Region (nur Intel x86-CPUs). Dies führt zu Cacheline-Fehlern
und Abwürgen von CPUs.

--lockbus-ops N
Lockbus-Mitarbeiter nach N-Bogo-Operationen anhalten.

--lockf N
Starten Sie N Worker, die zufällig Bereiche einer Datei mit dem POSIX sperren und entsperren
lockf(3) Verriegelungsmechanismus. Jeder Arbeiter erstellt eine 64K-Datei und versucht, eine Datei zu halten
maximal 1024 gleichzeitige Sperren mit einem Kindprozess, der auch versucht, 1024 . zu halten
gleichzeitige Sperren. Alte Schlösser werden nach dem First-In-First-Out-Prinzip entriegelt.

--lockf-ops N
Stoppen Sie Lockf-Arbeiter nach N bogo lockf-Operationen.

--lockf-nonblock
anstatt F_LOCK zu blockieren lockf(3) Befehle, verwenden Sie nicht blockierendes F_TLOCK
Befehle und versuchen Sie es erneut, wenn die Sperre fehlgeschlagen ist. Dadurch entsteht ein zusätzlicher Systemaufruf-Overhead
und CPU-Auslastung, wenn die Zahl der Lockf-Worker steigt und steigen sollte
Streit sperren.

--longjmp N
Starten Sie N Arbeiter, die trainieren setjmp(3) /langejmp(3) durch schnelles Loopen auf longjmp
Anrufe.

--longjmp-ops N
Stoppen Sie longjmp-Stressarbeiter nach N bogo longjmp-Operationen (1 bogo op ist 1000
longjmp-Aufrufe).

--lsuchen N
Starten Sie N Arbeiter, die ein unsortiertes Array von 32-Bit-Ganzzahlen linear durchsuchen, indem Sie
lsuchen(3). Standardmäßig enthält das Array 8192 Elemente. Dies ist ein nützliches
Verfahren zum Ausführen eines sequentiellen Zugriffs auf den Speicher und den Prozessorcache.

--lsearch-ops N
Stoppen Sie die lsearch-Worker, nachdem N bogo lsearch-Operationen abgeschlossen sind.

--lSuchgröße N
Geben Sie die Größe (Anzahl der 32-Bit-Ganzzahlen) im Array an, um lsearch. Größe kann sein
von 1K bis 4M.

- malloc N
Starte N Arbeiter, die ständig anrufen malloc(3) calloc(3) Realloc(3) und kostenlos(3).
Standardmäßig können zu jedem Zeitpunkt bis zu 65536 Zuweisungen aktiv sein, dies kann jedoch sein
mit der Option --malloc-max geändert. Zuteilung, Umverteilung und Freilassung sind
zufällig ausgewählt; 50% der Zeit wird Speicher zugewiesen (über malloc, calloc oder
realloc) und 50% der Zeitkontingente sind kostenlos. Zuteilungsgrößen sind auch
zufällig, wobei die maximale Zuweisungsgröße durch die Option --malloc-bytes gesteuert wird,
die Standardgröße ist 64K. Der Arbeiter wird neu gestartet, wenn er durch das Aus getötet wird
Memory (OOM) Killer.

--malloc-bytes N
maximal pro Zuweisungs-/Neuzuweisungsgröße. Zuteilungen werden zufällig ausgewählt aus 1
auf N Byte. Man kann die Größe in Einheiten von Bytes, KBytes, MBytes und GBytes angeben
mit dem Suffix b, k, m oder g. Große Zuordnungsgrößen bewirken, dass der Speicherzuordner
benutzen mmap(2) anstatt den Heap zu erweitern mit brk(2).

--malloc-max N
maximal zulässige Anzahl aktiver Zuweisungen. Allokationen werden zufällig gewählt und
in einem Zuordnungsslot platziert. Da sich etwa 50/50 % zwischen Zuteilung und
Beim Freigeben wird normalerweise die Hälfte der Zuweisungsschlitze gleichzeitig verwendet.

--malloc-ops N
Stopp nach N Malloc Bogo Operationen. One bogo Operationen bezieht sich auf ein erfolgreiches
malloc(3) calloc(3) oder Realloc(3).

--malloc-thresh N
Geben Sie den Schwellenwert an, den malloc verwendet mmap(2) statt sbrk(2) um mehr zuzuweisen
Erinnerung. Dies ist nur auf Systemen verfügbar, die das GNU C . bereitstellen mallopt(3) stimmen
Funktion.

--Matrix N
Starten Sie N Arbeiter, die verschiedene Matrixoperationen mit Gleitkommawerten ausführen. Von
Standardmäßig werden alle Matrixspannungsmethoden nacheinander ausgeführt. Man kann
Geben Sie mit der Option --matrix-method eine bestimmte Matrixspannungsmethode an.

--matrix-ops N
Stoppen Sie Matrix-Stressarbeiter nach N-Bogo-Operationen.

--matrix-methode Methode
spezifizieren Sie eine Matrixspannungsmethode. Verfügbare Matrixspannungsmethoden werden beschrieben als
folgt:

Methodik Beschreibung
alle iterieren über alle unten stehenden Matrixspannungsmethoden
addiere zwei N × N Matrizen hinzufügen
kopieren eine N × N-Matrix in eine andere kopieren
div dividiere eine N × N-Matrix durch einen Skalar
hadamard Hadamard-Produkt von zwei N × N Matrizen
frobenius Frobenius-Produkt zweier N × N Matrizen
mittleres arithmetisches Mittel von zwei N × N Matrizen
multipliziere eine N × N-Matrix mit einem Skalar
Produktprodukt zweier N × N Matrizen
subtrahiere eine N × N-Matrix von einer anderen N × N-Matrix
transponiere eine N × N-Matrix

--matrix-größe N
Geben Sie die N × N-Größe der Matrizen an. Kleinere Werte führen zu einem Gleitkomma
durchsatzgebundenen Stressor berechnen, wobei große Werte zu einem Cache führen und/oder
speicherbandbreitengebundener Stressor.

--membarriere N
Starte N Arbeiter, die den Membarrier-Systemaufruf ausführen (nur Linux).

--membarrier-ops N
Stoppen Sie Membarrier-Stressarbeiter nach N Bogo Membarrier-Operationen.

--memcpy N
Starten Sie N Worker, die 2 MB Daten aus einer gemeinsam genutzten Region in einen Puffer kopieren, indem Sie . verwenden
memcpy(3) und verschieben Sie dann die Daten in den Puffer mit memme(3) mit 3 verschiedenen
Ausrichtungen. Dies belastet den Prozessor-Cache und den Systemspeicher.

--memcpy-ops N
Stoppen Sie Memcpy-Stressarbeiter nach N-Bogo-Memcpy-Operationen.

--memfd N
Starten Sie N Arbeiter, die 256 Zuweisungen von 1024 Seiten erstellen, indem Sie . verwenden memfd_create(2) und
verkürzen(2) für die Zuteilung und mmap(2) die Zuordnung in den Prozess abzubilden
Adressraum. (Nur Linux).

--memfd-ops N
halt nach N memfd-erstellen(2) Bogo-Operationen.

--Zusammenführen, sortieren N
Starten Sie N Arbeiter, die 32-Bit-Ganzzahlen mit dem BSD-Mergesort sortieren.

--mergesort-ops N
Stoppen Sie Mergesort-Stressarbeiter nach N Bogo-Mergesorts.

--mergesort-size N
Geben Sie die Anzahl der zu sortierenden 32-Bit-Ganzzahlen an, der Standardwert ist 262144 (256 × 1024).

- Mincore N
Starten Sie N Arbeiter, die den gesamten Speicher durchlaufen 1 Seite nach der anderen Überprüfung der
Seite zugeordnet und ist auch im Speicher resident mit Mincore(2).

--mincore-ops N
Stoppen Sie nach N Mincore-Bogo-Operationen. Eine Mincore-Bogo-Op entspricht einem 1000
Mincore(2) Anrufe.

--mincore-random
Wählen Sie die Seiten nach dem Zufallsprinzip aus, anstatt nacheinander durch die Seiten zu gehen. Die Auserwählten
Adresse wird iteriert, indem sie um eine Stelle nach rechts verschoben und von Mincore überprüft wird
bis die Adresse kleiner oder gleich der Seitengröße ist.

--mknod N
Starten Sie N Arbeiter, die Fifos, leere Dateien und benannte Sockets erstellen und entfernen, indem Sie verwenden
mknod und Verknüpfung aufheben.

--mknod-ops N
Stoppen Sie Verzeichnis-Thrash-Worker nach N bogo mknod-Operationen.

--mlock N
Starten Sie N Worker, die speicherzugeordnete Seiten mit sperren und entsperren mlock(2)
Munlock(2) mlockall(2) und Munlockall(2). Dies wird erreicht durch die Abbildung von drei
zusammenhängende Seiten und dann Sperren der zweiten Seite, wodurch nicht zusammenhängende Seiten sichergestellt werden
Seiten sind gesperrt. Dies wird dann wiederholt, bis die maximal zulässigen mlocks oder a
Es werden maximal 262144 Zuordnungen erstellt. Als nächstes werden alle zukünftigen Zuordnungen mlocked und die
Worker versucht, 262144 Seiten zuzuordnen, dann werden alle Seiten entsperrt und die Seiten sind
nicht abgebildet.

--mlock-ops N
Stoppen Sie nach N mlock Bogo-Operationen.

--mmap N
Starte N Arbeiter, die ständig anrufen mmap(2) /Munmap(2). Die anfängliche Abbildung ist a
großer Chunk (Größe angegeben durch --mmap-bytes) gefolgt von pseudozufälligen 4K
Entmappings, dann pseudo-zufällige 4K-Mappings und dann lineare 4K-Entmappings. Notiz
dass dies dazu führen kann, dass Systeme den Kernel-OOM-Killer auf Linux-Systemen auslösen, wenn nicht
Es ist nicht genügend physischer Speicher und Swap verfügbar. Die Option MAP_POPULATE wird verwendet
um Seiten in den Speicher auf Systemen zu füllen, die dies unterstützen. Standardmäßig anonym
Mappings verwendet werden, die Optionen --mmap-file und --mmap-async erlauben jedoch,
Führen Sie auf Wunsch dateibasierte Zuordnungen durch.

--mmap-ops N
Stoppen Sie mmap-Stressarbeiter nach N-Bogo-Operationen.

--mmap-async
Aktivieren Sie die dateibasierte Speicherzuordnung und verwenden Sie asynchrones msync'ing auf jeder Seite, siehe
--mmap-Datei.

--mmap-bytes N
Weisen Sie N Bytes pro mmap-Stress-Worker zu, der Standardwert ist 256 MB. Man kann das spezifizieren
Größe in Einheiten von Bytes, KBytes, MBytes und GBytes mit dem Suffix b, k, m oder g.

--mmap-Datei
Aktivieren Sie die dateibasierte Speicherzuordnung und verwenden Sie standardmäßig synchrones msync'ing auf jedem


--mmap-mprotect
Ändern Sie die Schutzeinstellungen auf jeder Seite des Speichers. Jedes Mal, wenn eine Seite oder eine Gruppe von
Seiten zugeordnet oder neu zugeordnet werden, macht diese Option die Seiten schreibgeschützt, schreibgeschützt.
only, exec-only und read-write.

--mmapfork N
Starten Sie N Arbeiter, die jeweils 32 untergeordnete Prozesse abzweigen, von denen jeder versucht,
einen Teil des im System verbleibenden freien Speichers zuweisen (und versuchen, diesen zu vermeiden)
tauschen). Die untergeordneten Prozesse weisen dann darauf hin, dass die Zuweisung mit benötigt wird
verrückt(2) und dann memset es auf null und weist darauf hin, dass es nicht mehr benötigt wird mit
madvise vor dem Verlassen. Dies erzeugt erhebliche Mengen an VM-Aktivität, viele
Cache-Fehlschläge und mit minimalem Swapping.

--mmapfork-ops N
Halt nach N mmapfork Bogo-Operationen.

--mmapmany N
Starten Sie N Worker, die versuchen, den maximal zulässigen Arbeitsspeicher pro Prozess zu erstellen
Abbildungen. Dies wird durch das Zuordnen von 3 zusammenhängenden Seiten und das anschließende Aufheben der Zuordnung erreicht
mittlere Seite, wodurch das Mapping in zwei Teile geteilt wird. Dies wird dann wiederholt, bis die
maximal zulässige Zuordnungen oder maximal 262144 Zuordnungen vorgenommen werden.

--mmapmany-ops N
Stoppen Sie nach N mmapmany Bogo-Operationen.

--mremap N
Starte N Arbeiter, die ständig anrufen mmap(2) mremap(2) und Munmap(2). Die Initiale
anonyme Zuordnung ist ein großer Brocken (Größe wird durch --mremap-bytes angegeben) und dann
iterativ halbiert durch Neuzuordnung auf eine Seitengröße und dann
wieder auf die Originalgröße zurück. Dieser Worker ist nur für Linux verfügbar.

--mremap-ops N
Stoppen Sie mremap-Stressarbeiter nach N-Bogo-Operationen.

--mremap-bytes N
Weisen Sie zunächst N Bytes pro Remap-Stress-Worker zu, der Standardwert ist 256 MB. Man kann
geben Sie die Größe in Einheiten von Bytes, KBytes, MBytes und GBytes mit dem Suffix b an,
k, m oder g.

--Nachricht N
N Sender- und Empfängerprozesse starten, die kontinuierlich Nachrichten senden und empfangen
unter Verwendung von System V-Nachrichten-IPC.

--msg-ops N
stoppen, nachdem N Bogo-Nachrichtensendeoperationen abgeschlossen sind.

--mq N N Sender- und Empfängerprozesse starten, die kontinuierlich Nachrichten senden und empfangen
Verwenden von POSIX-Nachrichtenwarteschlangen. (Nur Linux).

--mq-ops N
stoppen, nachdem N bogo POSIX-Nachrichtensendeoperationen abgeschlossen sind.

--mq-Größe N
Geben Sie die Größe der POSIX-Nachrichtenwarteschlange an. Die Standardgröße beträgt 10 Nachrichten und die meisten Linux
Systemen ist dies die maximal zulässige Größe für normale Benutzer. Wenn die angegebene Größe ist
größer als die zulässige Nachrichtenwarteschlangengröße ist, wird eine Warnung ausgegeben und die
Stattdessen wird die maximal zulässige Größe verwendet.

--nett N
Starten Sie N CPU-verbrauchende Arbeiter, die die verfügbaren netten Ebenen ausüben. Jeder
Iteration spaltet einen untergeordneten Prozess ab, der alle schönen Level durchläuft
läuft eine Busy-Schleife für 0.1 Sekunden pro Level und wird dann beendet.

--nice-ops N
halt nach N schöne bogo schöne Schleifen

--Null N
Starten Sie N Arbeiter, die nach /dev/null schreiben.

--null-ops N
Stoppen Sie Null-Stress-Worker nach N /dev/null-bogo-Schreiboperationen.

--numa N
Starten Sie N Arbeiter, die Stressoren migrieren, und einen 4 MB Speicher zugeordneten Puffer um alle herum
die verfügbaren NUMA-Knoten. Dies verwendet migrieren_seiten(2) die Stressoren zu verschieben und
binden(2) und move_pages(2) um die Seiten des zugeordneten Puffers zu verschieben. Nach jeder Bewegung,
der Puffer wird geschrieben, um eine Aktivität über den Bus zu erzwingen, was zu Cache-Fehlversuchen führt.
Dieser Test wird nur auf Hardware mit aktiviertem NUMA und mehr als 1 NUMA-Knoten ausgeführt.

--numa-ops N
Stoppen Sie NUMA-Stressarbeiter nach N bogo NUMA-Operationen.

--oom-Rohr N
Beginnen Sie mit N Arbeitern, die so viele Rohre wie erlaubt erstellen und das Expandieren üben und
Schrumpfen der Rohre von der größten Rohrgröße auf eine Seitengröße. Daten werden geschrieben
in die Rohre ein und ausgelesen, um die Rohrpuffer zu füllen. Mit dem --aggressiven
Modus aktiviert die Daten werden beim Schrumpfen der Pipes nicht ausgelesen, wodurch der Kernel
gegenüber OOM-Prozessen aggressiv. Das Ausführen vieler Instanzen dieses Stressors wird erzwingen
Kernel zu OOM-Prozessen aufgrund der vielen großen Pipe-Puffer-Zuweisungen.

--oom-pipe-ops N
Stoppen Sie nach N-Bogo-Rohr-Aufweit-/Schrumpfvorgängen.

-o N, --offen N
Starte N Arbeiter die Leistung bringen XNUMXh geöffnet(2) und dann schließen(2) Operationen auf /dev/zero. Die
Die maximale Anzahl gleichzeitiger Öffnungen ist systemdefiniert, daher wird der Test bis zu diesem Punkt ausgeführt
Maximum oder 65536 offene Dateideskriptoren, je nachdem, was zuerst eintritt.

--open-ops N
Stoppen Sie die offenen Stressarbeiter nach N bogo offenen Operationen.

--Persönlichkeit N
Starten Sie N Arbeiter, die versuchen, die Persönlichkeit zu bestimmen und alles verfügbare zu erhalten
Persönlichkeitstypen (Prozessausführungsdomänentypen) über die Persönlichkeit zu zeigen.(2) System
Anruf. (Nur Linux).

--persönlichkeit-ops N
Stoppen Sie Persönlichkeitsstressarbeiter nach N-Bogo-Persönlichkeitsoperationen.

-p N, --Rohr N
Starten Sie N Worker, die große Pipe-Schreib- und Lesevorgänge ausführen, um Pipe-I/O auszuüben.
Dies übt Gedächtnis-Schreiben und -Lesevorgänge sowie Kontextwechsel. Jeder Arbeiter
hat zwei Prozesse, einen Reader und einen Writer.

--pipe-ops N
Stoppen Sie Rohrbelastungsarbeiter nach N Bogo-Pipe-Schreibvorgängen.

--pipe-data-size N
gibt die Größe in Byte jedes Schreibvorgangs in die Pipe an (Bereich von 4 Byte bis 4096
Byte). Das Einstellen einer kleinen Datengröße führt dazu, dass mehr Schreibvorgänge im gepuffert werden
pipe, wodurch die Kontextwechselrate zwischen dem Pipe-Writer und der Pipe reduziert wird
Reader-Prozesse. Standardgröße ist die Seitengröße.

--Rohrgröße N
gibt die Größe der Pipe in Bytes an (für Systeme, die das F_SETPIPE_SZ . unterstützen)
fcntl()-Befehl). Das Einstellen einer kleinen Rohrgröße führt dazu, dass sich das Rohr füllt und blockiert
häufiger, wodurch die Kontextwechselrate zwischen den Pipe-Writern erhöht wird
und die Pipe-Reader-Prozesse. Die Standardgröße beträgt 512 Byte.

-P N, --Umfrage N
Starten Sie N Worker, die eine Nullzeitüberschreitungsabfrage über den . durchführen Umfrage (2) wählen(2) und
Schlafstörungen(3) Anrufe. Dies verschwendet System- und Benutzerzeit mit Nichtstun.

--umfrage-ops N
Stoppen Sie Umfrage-Stressarbeiter nach N-Bogo-Umfrageoperationen.

--procfs N
Starten Sie N Arbeiter, die Dateien lesen von / proc und rekursiv Dateien auslesen von
/proc/selbst (Nur Linux).

--procfs-ops N
Stoppen Sie das Lesen von procfs nach N bogo-Lesevorgängen. Beachten Sie, da die Anzahl der Einträge
kann je nach Kernel variieren, diese Bogo-Ops-Metrik ist wahrscheinlich sehr irreführend.

--pthread N
starte N Arbeiter, die iterativ mehrere Pthreads erstellen und beenden (die
der Standardwert ist 1024 pthreads pro Worker). In jeder Iteration wird jeder neu erstellte pthread
wartet, bis der Worker alle Pthreads erstellt hat und dann alle beenden
together.

--pthread-ops N
Stoppen Sie pthread-Worker nach N bogo pthread create-Operationen.

--pthread-max N
Erstellen Sie N pthreads pro Worker. Wenn das Produkt der Anzahl der pThreads durch die
Anzahl der Arbeiter ist größer als die weiche Grenze der zulässigen P-Threads, dann die
Maximum wird auf das erlaubte Maximum zurückgeregelt.

--ptrace N
Starten Sie N Worker, die Systemaufrufe eines untergeordneten Prozesses verzweigen und verfolgen, indem Sie verwenden
ptrace(2).

--ptrace-ops N
ptracer-Worker stoppen, nachdem N bogo-Systemaufrufe verfolgt wurden.

-Q, --qsort N
Starten Sie N Arbeiter, die 32-Bit-Ganzzahlen mit qsort sortieren.

--qsort-ops N
Stoppen Sie qsort-Stressarbeiter nach N bogo qsorts.

--qsort-größe N
Geben Sie die Anzahl der zu sortierenden 32-Bit-Ganzzahlen an, der Standardwert ist 262144 (256 × 1024).

--Quote N
N Arbeiter starten, die Q_GETQUOTA, Q_GETFMT, Q_GETINFO, Q_GETSTATS und ausüben
Q_SYNC Quoctl(2) Befehle auf allen verfügbaren eingehängten blockbasierten Dateisystemen.

--quota-ops N
Stoppen Sie Quotenstressarbeiter nach N-Bogo-Quoten-Operationen.

--rdrand N
Starten Sie N Arbeiter, die den Zufallszahlengenerator der Intel-Hardware lesen (Intel
Ivybridge-Prozessoren aufwärts).

--rdrand-ops N
Stoppen Sie rdrand-Stressarbeiter nach N bogo rdrand-Operationen (1 bogo op = 2048 zufällig
Bits erfolgreich gelesen).

--lesen Sie weiter N
Starte N Worker, die nach dem Zufallsprinzip 512 Byte Lese-/Schreib-E/A-Operationen suchen und ausführen
auf einer Datei mit Readahead. Die Standarddateigröße beträgt 1 GB. Readaheads und Reads sind
in 16 Readaheads und dann 16 Reads gestapelt.

--Readahead-Bytes N
Legen Sie die Größe der Readahead-Datei fest, der Standardwert ist 1 GB. Man kann die Größe in angeben
Einheiten von Bytes, KBytes, MBytes und GBytes mit dem Suffix b, k, m oder g.

--readahead-ops N
Stoppen Sie Readahead-Stressarbeiter nach N Bogo-Lesevorgängen.

--remap N
Starten Sie N Worker, die 512 Seiten zuordnen, und ordnen Sie diese Seiten mit dem veralteten . neu an
Systemaufruf remap_file_pages(2). Es werden mehrere Neuordnungen von Seiten durchgeführt: vorwärts,
umkehren, zufällig und viele Seiten auf 1 Seite.

--remap-ops N
Stoppen Sie nach N Neuzuordnung von Bogo-Operationen.

-R N, --umbenennen N
Starten Sie N Arbeiter, die jeweils eine Datei erstellen und diese dann wiederholt umbenennen.

--rename-ops N
Stoppen Sie die Umbenennung von Stressarbeitern nach N bogo Umbenennungsvorgängen.

--rlimit N
Starte N Worker, die CPU- und Dateigrößen-Ressourcenimits überschreiten, wodurch SIGXCPU . generiert wird
und SIGXFSZ-Signale.

--rlimit-ops N
stoppen, nachdem N bogo ressourcenbegrenzte SIGXCPU- und SIGXFSZ-Signale abgefangen wurden.

--seccomp N
Starten Sie N Arbeiter, die die Systemaufruffilterung von Secure Computing ausüben. Jeder Arbeiter
erstellt untergeordnete Prozesse, die eine kurze Nachricht an /dev/null schreiben und dann beenden. 2%
der untergeordneten Prozesse haben einen Seccomp-Filter, der den Systemaufruf write nicht zulässt
und wird daher von seccomp mit einem SIGSYS getötet. Beachten Sie, dass dieser Stressor
jedes Mal, wenn das Kind getötet wird, viele Überwachungsprotokollnachrichten generieren.

--seccomp-ops N
Seccomp-Stressarbeiter nach N Seccomp-Filtertests stoppen.

--suchen N
Starte N Worker, die nach dem Zufallsprinzip 512 Byte Lese-/Schreib-E/A-Operationen suchen und ausführen
auf einer Datei. Die Standarddateigröße beträgt 16 GB.

--seek-ops N
Stoppen Sie die Suche nach Stressarbeitern nach N-Bogo-Suchoperationen.

--seek-punch
Stanzen Sie zufällig angeordnete 8K-Löcher in die Datei, um mehr Ausdehnungen zu erzwingen
anspruchsvoller Suchstressor, (nur Linux).

--Suche-Größe N
Geben Sie die Größe der Datei in Bytes an. Kleine Dateigrößen ermöglichen die E/A in
den Cache, was zu einer höheren CPU-Last führt. Große Dateigrößen zwingen zu mehr E/A-Operationen
Laufwerk verursacht mehr Wartezeit und mehr E/A auf dem Laufwerk. Man kann die Größe in angeben
Einheiten von Bytes, KBytes, MBytes und GBytes mit dem Suffix b, k, m oder g.

--sem N
Starte N Worker, die POSIX-Semaphor-Warte- und -Post-Operationen ausführen. Standardmäßig,
ein Elternteil und 4 Kinder werden pro Arbeiter gestartet, um einen gewissen Streit über die
Semaphor. Dies betont schnelle Semaphor-Operationen und erzeugt einen schnellen Kontext
Schalten.

--sem-ops N
Stoppen Sie Semaphor-Stressarbeiter nach N-Bogo-Semaphor-Operationen.

--sem-procs N
Starte N Kinderarbeiter pro Arbeiter, um einen Streit um das Semaphor zu liefern, das
Standard ist 4 und maximal 64 sind erlaubt.

--sem-sysv N
Starten Sie N Worker, die Semaphore-Warte- und -Post-Operationen von System V ausführen. Durch
Standardmäßig werden ein Elternteil und 4 Kinder pro Arbeiter gestartet, um einen Widerspruch zu schaffen
auf dem Semaphor. Dies betont schnelle Semaphor-Operationen und erzeugt schnelle
Kontextwechsel.

--sem-sysv-ops N
Stoppen Sie Semaphor-Stressarbeiter nach N-Bogo-System-V-Semaphor-Operationen.

--sem-sysv-procs N
Starten Sie N untergeordnete Prozesse pro Worker, um einen Konflikt mit dem System V-Semaphor bereitzustellen,
der Standardwert ist 4 und es sind maximal 64 zulässig.

--Datei senden N
Starte N Worker, die eine leere Datei an /dev/null senden. Diese Operation verbringt fast
die ganze Zeit im Kernel. Die Standardgröße der Sendedatei beträgt 4 MB. Die Sendedatei
Optionen sind nur für Linux.

--sendfile-ops N
stop sendfile-Worker nach N sendfile-bogo-Operationen.

--sendfile-size S
geben Sie die Größe an, die bei jedem sendfile-Aufruf kopiert werden soll. Die Standardgröße beträgt 4 MB. Eins
kann die Größe in Einheiten von Bytes, KBytes, MBytes und GBytes mit dem Suffix angeben
b, k, m oder g.

--shm N
Starten Sie N Worker, die Shared-Memory-Objekte unter Verwendung des POSIX-Shared . öffnen und zuweisen
Speicherschnittstellen. Standardmäßig erstellt und zerstört der Test wiederholt 32
Shared Memory-Objekte, von denen jedes 8 MB groß ist.

--shm-ops N
Stoppen Sie, nachdem N POSIX-Shared-Memory-Erstellungs- und -Zerstörungsoperationen abgeschlossen sind.

--shm-bytes N
Geben Sie die Größe der zu erstellenden POSIX-Shared-Memory-Objekte an. Man kann spezifizieren
die Größe in Einheiten von Bytes, KBytes, MBytes und GBytes mit dem Suffix b, k, m oder
g.

--shm-objs N
Geben Sie die Anzahl der zu erstellenden Shared-Memory-Objekte an.

--shm-sysv N
Starten Sie N Worker, die gemeinsam genutzten Speicher unter Verwendung des gemeinsam genutzten Speichers von System V zuweisen
Schnittstelle. Standardmäßig erstellt und zerstört der Test wiederholt 8 Shared Memory
Segmente, von denen jedes 8 MB groß ist.

--shm-sysv-ops N
Stoppen Sie, nachdem N Shared-Memory-Erzeugungs- und -Zerstörungsoperationen abgeschlossen sind.

--shm-sysv-bytes N
Geben Sie die Größe des zu erstellenden Shared-Memory-Segments an. Man kann das spezifizieren
Größe in Einheiten von Bytes, KBytes, MBytes und GBytes mit dem Suffix b, k, m oder g.

--shm-sysv-segs N
Geben Sie die Anzahl der zu erstellenden Shared-Memory-Segmente an.

--sigfd N
Starte N Arbeiter, die SIGRT-Signale erzeugen und von einem Kind gelesen werden
Prozess mit einem Dateideskriptor, der mit eingerichtet wurde signalfd(2). (Nur Linux). Dieser Wille
eine hohe Kontextwechsellast erzeugen, wenn alle CPUs voll ausgelastet sind.

--sigfd-ops
Stoppen Sie sigfd-Arbeiter, nachdem N bogo SIGUSR1-Signale gesendet wurden.

--sigfpe N
Starten Sie N Arbeiter, die schnell eine Division durch null SIGFPE-Fehler verursachen.

--sigfpe-ops N
Stoppen Sie Sigfpe-Stressarbeiter nach N bogo SIGFPE-Fehlern.

--signieren N
Starte N Arbeiter, die prüfen, ob SIGUSR1-Signale anstehen. Dieser Stressor maskiert
SIGUSR1, erzeugt ein SIGUSR1-Signal und verwendet Unterzeichnung(2) um zu sehen, ob das Signal
steht aus. Dann demaskiert es das Signal und prüft, ob das Signal nicht mehr ansteht.

--signpending-ops N
Stoppen Sie die Sigpendierung von Stressarbeitern nach N bogo Sigpending anhängigen/unpending Checks.

--sigsegv N
Starten Sie N Arbeiter, die Segmentierungsfehler schnell erzeugen und abfangen.

--sigsegv-ops N
Stoppen Sie sigsegv-Stressarbeiter nach N bogo-Segmentierungsfehlern.

--sigsuspend N
Starte N Arbeiter, die jeweils 4 untergeordnete Prozesse hervorbringen, die auf einen SIGUSR1 warten
Signal von den Eltern mit sigaussetzen(2). Der Elternteil sendet SIGUSR1-Signale an
jedes Kind in schneller Folge. Jedes sigsuspend-Wakeup wird als ein Bogo gezählt
Erfassung sind.

--sigsuspend-ops N
Stoppen Sie sigsuspend Stressarbeiter nach N bogo sigsuspend Wakeups.

--sigq N
Starten Sie N Arbeiter, die schnell SIGUSR1-Signale senden, indem Sie Schlange(3) zum Kind
Prozesse, die auf das Signal warten über sigwaitinfo(2).

--sigq-ops N
Stoppen Sie Sigq-Stressarbeiter, nachdem N-Bogo-Signale gesendet wurden.

--Schlaf N
Starte N Worker, die mehrere Threads spawnen, die jeweils mehrere Sleeps ausführen
von Bereichen 1us bis 0.1s. Dadurch werden mehrere Kontextwechsel und Timer erstellt
unterbricht.

--Schlaf-Ops N
Stoppen Sie nach N Schlafbogo-Operationen.

--Schlaf-max P
Starten Sie P-Threads pro Arbeiter. Der Standardwert ist 1024, der maximal zulässige Wert ist 30000.

-S N, --Socke N
Starten Sie N Arbeiter, die verschiedene Socket-Stress-Aktivitäten ausführen. Es handelt sich um ein Paar
von Client/Server-Prozessen, die schnelles Verbinden, Senden und Empfangen durchführen und
trennt die Verbindung auf dem lokalen Host.

--sock-domain D
Geben Sie die zu verwendende Domäne an, der Standardwert ist IPv4. Derzeit sind IPv4, IPv6 und Unix
unterstützt.

--sock-nodelay
Dadurch wird der TCP-Nagle-Algorithmus deaktiviert, sodass Datensegmente immer gesendet werden, sobald
möglich. Dadurch wird verhindert, dass Daten vor der Übertragung gepuffert werden
was zu einer schlechteren Netzwerkauslastung und mehr Kontextwechseln zwischen den
Sender und Empfänger.

--sock-port P
Beginnen Sie am Socket-Port P. Für N Socket-Worker-Prozesse werden die Ports P bis P - 1 verwendet.

--sock-ops N
Stoppen Sie Socket-Stressarbeiter nach N-Bogo-Operationen.

--sock-opts [ senden | sendmsg | sendmmsg ]
Standardmäßig werden Nachrichten mit gesendet senden(2). Diese Option ermöglicht die Angabe der
Sendemethode mit senden(2) sendmsg(2) oder sendmmsg(2). Beachten Sie, dass sendmmsg
nur für Linux-Systeme verfügbar, die diesen Systemaufruf unterstützen.

--sockfd N
Starten Sie N Worker, die Dateideskriptoren über einen UNIX-Domänen-Socket mit dem
CMSG(3) Hilfsdatenmechanismus. Für jeden Worker ein Paar von Client/Server-Prozessen
erstellt werden, öffnet der Server so viele Dateideskriptoren wie möglich auf /dev/null und
Übergeben dieser über den Socket an einen Client, der diese aus den CMSG-Daten liest und
schließt die Dateien sofort.

--sockfd-ops N
Stoppen Sie Sockfd-Stressarbeiter nach N-Bogo-Operationen.

--sockenpaar N
Starten Sie N Worker, die Lese-/Schreibvorgänge für Socketpaar-E/A ausführen. Dabei handelt es sich um ein Paar
Client/Server-Prozesse, die Socket-E/A-Operationen mit zufälliger Größe ausführen.

--sockpair-ops N
Stop-Socket-Paar-Stressarbeiter nach N-Bogo-Operationen.

--laichen N
Starten Sie N Arbeiter, die kontinuierlich Kinder hervorbringen, indem Sie verwenden posix_spawn(3) dass exec stress-ng
und dann fast sofort verlassen.

--spawn-ops N
Stoppen Sie Spawn-Stressarbeiter nach N-Bogo-Spawns.

--spleißen N
Verschieben Sie Daten von /dev/zero nach /dev/null durch eine Pipe, ohne zwischendurch zu kopieren
Kernel-Adressraum und Benutzer-Adressraum mit spleißen(2). Das ist nur verfügbar
für Linux.

--spleiß-ops N
Stoppen Sie nach N Bogo-Spleißvorgängen.

--spleiß-Bytes N
N Bytes pro Spleißaufruf übertragen, der Standardwert ist 64 KB. Man kann die Größe in angeben
Einheiten von Bytes, KBytes, MBytes und GBytes mit dem Suffix b, k, m oder g.

--Stapel N
Starten Sie N Arbeiter, die Stapelüberläufe schnell verursachen und abfangen, indem Sie verwenden zuteilen(3).

--stapel-voll
die Standardaktion besteht darin, die unterste Seite bei jeder Stapelzuweisung zu berühren. Dies
Option berührt alle Seiten, indem sie die neue Stapelzuordnung mit Nullen füllt, was
erzwingt die Zuweisung physischer Seiten und ist daher aggressiver.

--stack-ops N
Stoppen Sie Stack-Stressarbeiter nach N Bogo-Stack-Überläufen.

-str N
starte N Arbeiter, die verschiedene libc-Stringfunktionen auf zufällige Strings ausüben.

--str-Methode strfunc
Wählen Sie eine bestimmte libc-String-Funktion aus, die Sie betonen möchten. Verfügbare String-Funktionen für
Stress sind: all, index, rindex, strcasecmp, strcat, strchr, strcoll, strcmp,
strcpy, strlen, strncasecmp, strncat, strncmp, strrchr und strxfrm. Sehen Schnur(3)
Weitere Informationen zu diesen Zeichenfolgenfunktionen. Die Methode 'all' ist die Standardeinstellung
und übt alle String-Methoden aus.

--str-ops N
Stoppen Sie nach N Bogo-String-Operationen.

--Strom N
Beginnen Sie mit N Arbeitern, die einen Stressor für die Gedächtnisbandbreite ausüben, der lose auf dem STREAM basiert
Benchmarking-Tool "Sustainable Memory Bandwidth in High Performance Computers" von
John D. McCalpin, Ph.D. Dieser Stressor weist Puffer zu, die mindestens das 4-fache betragen
die Größe des CPU-L2-Cache und führt kontinuierlich folgende Runden durch
Berechnungen für große Arrays von Gleitkommazahlen mit doppelter Genauigkeit:

Produktion Beschreibung
c[i] = a[i] kopieren
Skala b[i] = Skalar * c[i]
c[i] hinzufügen = a[i] + b[i]
Triade a[i] = b[i] + (c[i] * Skalar)

Da dies lose auf einer Variante des STREAM-Benchmark-Codes basiert, NICHT
Ergebnisse auf dieser Grundlage einreichen, wie es in Stress-ng nur zum Stress gedacht ist
Speicher und Rechenleistung und NICHT für STREAM gedacht, genau abgestimmt oder nicht abgestimmt
Benchmarking was auch immer. Verwenden Sie auf Wunsch das offizielle STREAM-Benchmarking-Tool
genaue und standardisierte STREAM-Benchmarks.

--stream-ops N
Stoppen Sie nach N-Stream-Bogo-Operationen, wobei eine Bogo-Operation eine Kopierrunde ist,
Skalierungs-, Additions- und Triadenoperationen.

--stream-l3-Größe N
Geben Sie die Cachegröße der CPU-Ebene 3 in Byte an. Man kann die Größe in Einheiten von angeben
Bytes, KBytes, MBytes und GBytes mit dem Suffix b, k, m oder g. Wenn der L3-Cache
size nicht angegeben ist, versucht stress-ng, die Cache-Größe zu bestimmen, und
Andernfalls wird die Größe standardmäßig auf 4 MB festgelegt.

-s N, --Schalter N
Starten Sie N Worker, die Nachrichten per Pipe an ein Kind senden, um einen Kontextwechsel zu erzwingen.

--switch-ops N
Kontextwechsel-Worker nach N Bogo-Operationen stoppen.

- Symlink N
Starten Sie N Arbeiter, die symbolische Links erstellen und entfernen.

--symlink-ops N
Stoppen Sie Symlink-Stressarbeiter nach N-Bogo-Operationen.

--sync-Datei N
Starten Sie N Worker, die eine Reihe von Datensynchronisierungen über eine Datei hinweg durchführen, indem Sie verwenden
sync_file_range(2). Es werden drei Mischungen von Synchronisierungen durchgeführt, von Anfang bis Ende von
die Datei, vom Ende der Datei bis zum Anfang, und eine zufällige Mischung. Eine zufällige Auswahl
gültiger Sync-Typen verwendet werden, die SYNC_FILE_RANGE_WAIT_BEFORE abdecken,
SYNC_FILE_RANGE_WRITE und SYNC_FILE_RANGE_WAIT_AFTER Flag-Bits.

--sync-file-ops N
Stoppen Sie Sync-Datei-Worker nach N Bogo-Sync-Vorgängen.

--sync-file-bytes N
Geben Sie die Größe der zu synchronisierenden Datei an. Man kann die Größe in Einheiten von angeben
Bytes, KBytes, MBytes und GBytes mit dem Suffix b, k, m oder g.

--sysinfo N
Starten Sie N Arbeiter, die kontinuierlich Systeminformationen lesen und spezifische Informationen verarbeiten.
Dieser liest die Prozessbenutzer- und Systemzeiten über die mal(2) Systemaufruf. Für
Linux-Systemen liest es auch die Gesamtsystemstatistik mithilfe der Sysinfo(2) System
Aufruf und auch die Dateisystemstatistiken für alle gemounteten Dateisysteme mit
Statistiken(2).

--sysinfo-ops N
Stoppen Sie die Sysinfo-Worker nach N bogo-Operationen.

--sysfs N
N Worker starten, die rekursiv Dateien auslesen / sys (Nur Linux). Dies kann dazu führen, dass
bestimmte Kernel-Treiber, um Nachrichten in das Kernel-Log auszugeben.

--sys-ops N
Stoppen Sie das Lesen von sysfs nach N bogo-Lesevorgängen. Beachten Sie, da die Anzahl der Einträge
kann je nach Kernel variieren, diese Bogo-Ops-Metrik ist wahrscheinlich sehr irreführend.

- Abschlag N
Verschieben Sie Daten von einem Writer-Prozess zu einem Reader-Prozess durch Pipes und nach /dev/null
ohne Kopieren zwischen Kernel-Adressraum und Benutzer-Adressraum mit
Abschlag(2). Dies ist nur für Linux verfügbar.

--tee-ops N
Stopp nach N Bogo Abschlag.

-T N, --Timer N
Starten Sie N Arbeiter, die Timer-Ereignisse mit einer Standardrate von 1 MHz erstellen (nur Linux); Dies
kann viele tausend Timer-Interrupts erzeugen. Jedes Timer-Ereignis wird abgefangen
von einem Signalhandler und zählt als Bogo-Timer-Op.

--timer-ops N
Stoppen Sie Timer-Stressarbeiter nach N Bogo-Timer-Ereignissen (nur Linux).

--timer-freq F
Timer bei F Hz laufen lassen; Bereich von 1 bis 1000000000 Hz (nur Linux). Durch Auswahl eines
Stress-ng mit angemessener Frequenz kann Hunderttausende von Unterbrechungen erzeugen
pro Sekunde.

--timer-rand
Wählen Sie eine Timer-Frequenz basierend auf der Timer-Frequenz +/- 12.5% zufälliger Jitter.
Dadurch wird versucht, mehr Variabilität im Timer-Intervall zu erzwingen, um die Planung zu machen
weniger vorhersehbar.

--timerfd N
Starten Sie N Arbeiter, die timerfd-Ereignisse mit einer Standardrate von 1 MHz erstellen (nur Linux);
dies kann viele tausend Timer-Ereignisse erzeugen. Auf Timer-Ereignisse wird gewartet
auf dem Timer-Dateideskriptor mit wählen(2) und dann gelesen und als bogo gezählt
timerfd op.

--timerfd-ops N
Stoppen Sie timerfd-Stressarbeiter nach N bogo timerfd-Ereignissen (nur Linux).

--timerfd-freq F
Timer bei F Hz laufen lassen; Bereich von 1 bis 1000000000 Hz (nur Linux). Durch Auswahl eines
Stress-ng mit angemessener Frequenz kann Hunderttausende von Unterbrechungen erzeugen
pro Sekunde.

--timerfd-rand
Wählen Sie eine Timer-Frequenz basierend auf der Timer-Frequenz +/- 12.5 % zufällig
zittern. Dies versucht, mehr Variabilität im Timer-Intervall zu erzwingen, um die
weniger vorhersehbare Planung.

--tsc N
Starte N Arbeiter, die den Zeitstempelzähler (TSC) 256 Mal pro Schleifeniteration lesen
(Bogo-Betrieb). Nur auf Intel x86-Plattformen verfügbar.

--tsc-ops N
Stoppen Sie die tsc-Arbeiter, nachdem N Bogo-Operationen abgeschlossen sind.

--tsuchen N
Starte N Arbeiter, die 32-Bit-Ganzzahlen in einem Binärbaum einfügen, suchen und löschen
mit automatisierten tsuchen(3) tfinden(3) und tlöschen(3). Standardmäßig gibt es 65536 randomisierte
Ganzzahlen, die im Baum verwendet werden. Dies ist eine nützliche Methode, um den wahlfreien Zugriff auf
Speicher und Prozessorcache.

--tsearch-ops N
Stoppen Sie die tsearch-Worker, nachdem N Bogo-Tree-Operationen abgeschlossen sind.

--tSuchgröße N
Geben Sie die Größe (Anzahl der 32-Bit-Ganzzahlen) im Array für tsearch an. Größe kann sein
von 1K bis 4M.

--udp N
Starten Sie N Worker, die Daten mit UDP übertragen. Dabei handelt es sich um ein Paar Client/Server
Prozesse, die schnelles Verbinden, Senden und Empfangen und Trennen auf lokaler Ebene ausführen
Gastgeber.

--udp-Domain D
Geben Sie die zu verwendende Domäne an, der Standardwert ist IPv4. Derzeit sind IPv4, IPv6 und Unix
unterstützt.

--udp-lite
Verwenden Sie das Protokoll UDP-Lite (RFC 3828) (nur für IPv4- und IPv4-Domänen).

--udp-ops N
Stoppen Sie UDP-Stressarbeiter nach N-Bogo-Operationen.

--Udp-hafen P
Beginnen Sie bei Port P. Für N udp-Worker-Prozesse werden die Ports P bis P - 1 verwendet. Standardmäßig,
Ports ab 7000 werden verwendet.

--udp-flut N
Starten Sie N Worker, die versuchen, den Host mit UDP-Paketen an zufällige Ports zu fluten.
Die IP-Adresse der Pakete wird derzeit nicht gefälscht. Dies ist nur verfügbar auf
Systeme, die AF_PACKET unterstützen.

--udp-flood-domain D
Geben Sie die zu verwendende Domäne an, der Standardwert ist IPv4. Derzeit sind IPv4 und IPv6
unterstützt.

--udp-flood-ops N
Stoppen Sie udp-Flood-Stressarbeiter nach N-Bogo-Operationen.

- Freigabe aufheben N
Starten Sie N Arbeiter, die jeweils 32 untergeordnete Prozesse abzweigen, von denen jeder die
aufheben(2) Systemaufruf durch Trennen von Teilen des Prozessausführungskontexts.
(Nur Linux).

--unshare-ops N
Stoppen Sie nach N bogo Unshare-Operationen.

-u N, --urandom N
Starte N Arbeiter mit dem Lesen von /dev/urandom (nur Linux). Dadurch wird der Kernel zufällig geladen
Nummer Quelle.

--urandom-ops N
Stoppen Sie Urandom-Stressarbeiter nach N urandom-Bogo-Leseoperationen (nur Linux).

--userfaultfd N
Starte N Worker, die Fehler beim Schreiben von Seiten auf einem kleinen anonym zugeordneten erzeugen
Speicherbereich und behandeln Sie diese Fehler mit der Fehlerbehandlung des Benutzerbereichs über die
userfaultfd-Mechanismus. Dies führt zu einer großen Anzahl von schwerwiegenden Seitenfehlern und
auch Kontextwechsel während der Behandlung der Seitenfehler. (Nur Linux).

--userfaultfd-ops N
stop userfaultfd Stressworker nach N Seitenfehlern.

--userfaultfd-bytes N
mmap N Bytes pro userfaultfd-Worker zum Seitenfehler, der Standardwert ist 16 MB
geben Sie die Größe in Einheiten von Bytes, KBytes, MBytes und GBytes mit dem Suffix b an,
k, m oder g.

--utime N
Starten Sie N Arbeiter, die Dateizeitstempel aktualisieren. Dies ist hauptsächlich CPU-gebunden, wenn die Standardeinstellung
wird verwendet, da das System Metadatenänderungen nur periodisch löscht.

--utime-ops N
Stoppen Sie utime-Stressarbeiter nach Nutime-Bogo-Operationen.

--utime-fsync
Erzwingen Sie, dass Metadatenänderungen bei jeder Dateizeitstempelaktualisierung auf den Datenträger geschrieben werden. Dies
zwingt den Test, E/A-gebunden zu werden, und führt zu vielen schmutzigen Metadaten-Schreibvorgängen.

--vecmath N
Starte N Arbeiter, die verschiedene mathematische Operationen mit ganzen Zahlen ohne Vorzeichen auf verschiedenen . ausführen
128-Bit-Vektoren. Eine Mischung aus vektormathematischen Operationen wird auf folgendem ausgeführt
Vektoren: 16 × 8 Bit, 8 × 16 Bit, 4 × 32 Bit, 2 × 64 Bit. Die erzeugten Metriken
durch diese Mischung hängen von der Prozessorarchitektur und den Vektormathematik-Optimierungen ab
vom Compiler erzeugt.

--vecmath-ops N
Stoppen Sie nach N ganzzahligen mathematischen Operationen mit Bogo-Vektoren.

--vfork N
Beginnen Sie mit N Arbeitern, die kontinuierlich Kinder abzweigen, die sofort aussteigen.

--vfork-ops N
Stoppen Sie Vfork-Stressarbeiter nach N-Bogo-Operationen.

--vfork-max P
P-Prozesse erstellen und dann warten, bis sie pro Iteration beendet werden. Die Standardeinstellung ist
nur 1; höhere Werte erzeugen viele temporäre Zombie-Prozesse, die warten
geerntet werden. Mit hohen Werten kann man potentiell die Prozesstabelle auffüllen
für --vfork-max und --vfork.

-m N, --vm N
Starte N Arbeiter, die ständig anrufen mmap(2) /Munmap(2) und schreiben an die zugewiesenen
Erinnerung. Beachten Sie, dass dies dazu führen kann, dass Systeme den Kernel-OOM-Killer unter Linux auslösen
Systeme, wenn nicht genügend physischer Speicher und Swap nicht verfügbar sind.

--vm-bytes N
mmap N Byte pro VM-Worker, der Standardwert ist 256 MB. Man kann die Größe in Einheiten angeben
von Bytes, KBytes, MBytes und GBytes mit dem Suffix b, k, m oder g.

--vm-schritt N
veraltet seit Version 0.03.02

--vm-ops N
Stoppen Sie VM-Arbeiter nach N-Bogo-Operationen.

--vm-hängen N
Schlaf N Sekunden, bevor die Speicherzuordnung aufgehoben wird, der Standardwert ist null Sekunden. Angabe von 0
wird endlos warten.

--vm-keep
nicht ständig den Speicher aufheben und zuordnen, sondern einfach immer wieder neu darauf schreiben.

--vm-gesperrt
Sperren Sie die Seiten der abgebildeten Region mit mmap MAP_LOCKED im Speicher (seit Linux
2.5.37). Dies ist vergleichbar mit dem Sperren des Speichers, wie in beschrieben mlock(2).

--vm-Methode m
spezifizieren Sie eine VM-Stress-Methode. Standardmäßig werden alle Stressmethoden ausgeübt
sequentiell, man kann jedoch bei Bedarf nur eine Methode angeben, die verwendet werden soll. Jeder
der VM-Worker haben 3 Phasen:

1. Initialisiert. Der anonym speicherabgebildete Bereich wird auf ein bekanntes Muster eingestellt.

2. Ausgeübt. Der Speicher wird auf bekannte vorhersagbare Weise modifiziert. Einige VM-Arbeiter ändern sich
Speicher sequentiell, einige verwenden kleine oder große Schritte, um den Speicher voranzutreiben.

3. Geprüft. Der geänderte Speicher wird überprüft, um zu sehen, ob er mit dem erwarteten übereinstimmt
Ergebnis.

Die VM-Methoden, die 'prime' in ihrem Namen enthalten, haben einen Schritt der größten Primzahl
weniger als 2^64, was ihnen erlaubt, gründlich durch die Erinnerung zu gehen und alles zu berühren
Speicherorte nur einmal, wobei auch darauf verzichtet wird, benachbarte Speicherzellen zu berühren
andere. Diese Strategie übt die Cache- und Seiten-Nichtlokalität aus.

Da das trainierte Gedächtnis virtuell abgebildet wird, gibt es keine Garantie für
Berühren von Seitenadressen in einer bestimmten physischen Reihenfolge. Diese Arbeiter sollten nicht
Verwenden Sie Tools, um zu testen, ob der gesamte Speicher des Systems ordnungsgemäß funktioniert
wie memtest86 stattdessen.

Die vm-Stress-Methoden sollen das Gedächtnis trainieren, um möglicherweise zu finden
Speicherprobleme und versuchen, thermische Fehler zu erzwingen.

Verfügbare vm-Stress-Methoden werden wie folgt beschrieben:

Methodik Beschreibung
alle iterieren über alle VM-Stress-Methoden, wie unten aufgeführt.
Flip sequentiell 8 Mal durch den Speicher arbeiten, jedes Mal nur
ein Bit im Speicher umgedreht (invertiert). Dies wird effektiv
invertieren Sie jedes Byte in 8 Durchgängen.
galpat-0 galoppierende Muster Nullen. Dies setzt alle Bits auf 0 und kippt um
nur 1 in 4096 Bits zu 1. Es prüft dann, ob die 1s
werden von ihren Nachbarn oder von den . auf 0 heruntergezogen
Nachbarn wurden auf 1 gezogen.
galpat-1 galoppierende Muster. Dadurch werden alle Bits auf 1 gesetzt und gedreht
nur 1 in 4096 Bits zu 0. Es prüft dann, ob die 0s
werden von ihren Nachbarn oder von den Nachbarn auf 1 gezogen
wurden auf 0 heruntergezogen.
grau den Speicher mit sequentiellen Gray-Codes füllen (nur diese
jeweils 1 Bit zwischen benachbarten Bytes ändern) und dann
überprüfen Sie, ob sie richtig eingestellt sind.
incdec arbeitet zweimal sequentiell durch den Speicher, den ersten Durchgang
erhöht jedes Byte um einen bestimmten Wert und die Sekunde
pass dekrementiert jedes Byte zurück auf den ursprünglichen Startwert.
Der Inkrement-/Dekrementwert ändert sich bei jedem Aufruf von
der Stressfaktor.
inc-nybble initialisiert den Speicher auf einen eingestellten Wert (der sich bei jedem ändert).
Aufruf des Stressors) und dann nacheinander arbeiten
durch jedes Byte inkrementieren die unteren 4 Bits um 1 und
die oberen 4 Bits mit 15.
rand-set arbeitet sequentiell durch den Speicher in der 64-Bit-Chunks-Einstellung
Bytes im Chunk auf denselben 8-Bit-Zufallswert. Der
zufälliger Wert ändert sich bei jedem Chunk. Überprüfen Sie, ob die Werte
haben sich nicht geändert.
rand-sum setzt sequentiell den gesamten Speicher auf zufällige Werte und dann
Summieren Sie die Anzahl der Bits, die sich gegenüber dem geändert haben
ursprünglich eingestellte Werte.
read64 sequentielles Lesen des Speichers mit 32 x 64-Bit-Lesevorgängen pro Bogo
Schleife. Jede Schleife entspricht einer Bogo-Operation. Dies
übt rohes Gedächtnis liest.
ror Speicher mit einem zufälligen Muster füllen und dann sequentiell
drehe 64 Bits des Speichers um ein Bit nach rechts und überprüfe dann das
letztes Laden/Drehen/gespeicherte Werte.
Swap-Speicher in 64-Byte-Blöcken mit zufälligen Mustern füllen. Dann
tausche jeden 64 Chunk mit einem zufällig ausgewählten Chunk aus. Endlich,
kehren Sie den Swap um, um die Stücke wieder in ihren ursprünglichen Zustand zu versetzen
Platzieren und prüfen, ob die Daten korrekt sind. Diese Übungen
benachbartes und zufälliges Laden/Speichern des Speichers.
move-inv sequentiell Speicher 64 Bit Speicher gleichzeitig füllen mit
Zufallswerte und dann prüfen, ob der Speicher eingestellt ist
korrekt. Als nächstes invertieren Sie jedes 64-Bit-Muster sequentiell
und überprüfen Sie erneut, ob der Speicher wie erwartet eingestellt ist.

Modulo-X-Speicher über 23 Iterationen füllen. Jede Iteration beginnt eine
Byte weiter vom Anfang des Speichers und der Schritte
zusammen in 23 Byte-Schritten. In jedem Schritt ist das erste Byte
auf ein zufälliges Muster gesetzt und alle anderen Bytes werden auf die gesetzt
umgekehrt. Dann prüft es, ob das erste Byte die enthält
erwartetes Zufallsmuster. Dies trainiert Cache-Speichern/-Lesevorgänge
sowie zu sehen, ob benachbarte Zellen sich gegenseitig beeinflussen
anderen.
prime-0 iteriere 8 Mal, indem du den Speicher in sehr großen Schritten durchgehst
Prime-Schritte löschen nur bitweise in jedem Byte.
Prüfen Sie dann, ob alle Bits auf Null gesetzt sind.
prime-1 iteriere 8 Mal, indem du den Speicher in sehr großen Schritten durchgehst
Prime-Schritte setzen nur bitweise in jedem Byte.
Prüfen Sie dann, ob alle Bits auf eins gesetzt sind.
prime-grey-0 erster Schritt durch das Gedächtnis in sehr großen Prime-Schritten
Löschen nur auf Bit (basierend auf einem Gray-Code) in jedem Byte.
Als nächstes wiederholen Sie dies, aber löschen Sie die anderen 7 Bits. Dann schau nach
Sehen Sie, ob alle Bits auf Null gesetzt sind.
prime-grey-1 erster Schritt durch das Gedächtnis in sehr großen Prime-Schritten
Einstellung nur auf Bit (basierend auf einem Gray-Code) in jedem Byte.
Als nächstes wiederholen Sie dies, aber setzen Sie die anderen 7 Bits. Dann schau nach
Sehen Sie, ob alle Bits auf eins gesetzt sind.
Rowhammer versuchen, eine Speicherbeschädigung mit dem Rowhammer-Speicher zu erzwingen
Stressfaktor. Dies holt zwei 32-Bit-Ganzzahlen aus dem Speicher und
erzwingt mehrmals einen Cache-Flush für die beiden Adressen.
Es ist bekannt, dass dies bei einigen Geräten das Bit-Flipping erzwingt.
insbesondere bei Speicherauffrischungszyklen mit niedrigerer Frequenz.
walk-0d für jedes Byte im Speicher, gehen Sie durch jede Datenzeile
Setzen Sie sie auf niedrig (und die anderen sind hoch) und überprüfen Sie
dass der geschriebene Wert wie erwartet ist. Dies überprüft, ob überhaupt
Datenleitungen stecken fest.
walk-1d für jedes Byte im Speicher, gehen Sie durch jede Datenzeile
Stellen Sie sie auf hoch (und die anderen sind auf niedrig eingestellt) und überprüfen Sie
dass der geschriebene Wert wie erwartet ist. Dies überprüft, ob überhaupt
Datenleitungen stecken fest.
walk-0a in der gegebenen Speicherzuordnung, arbeite durch eine Reihe von
speziell ausgewählte Adressen arbeiten durch Adresszeilen zu
Überprüfen Sie, ob Adressleitungen niedrig stecken. Das funktioniert am besten
mit physischer Speicheradressierung jedoch, diese auszuüben
virtuelle Adressen haben auch einen gewissen Wert.
walk-1a in der gegebenen Speicherzuordnung, arbeite durch eine Reihe von
speziell ausgewählte Adressen arbeiten durch Adresszeilen zu
sehen Sie, ob irgendwelche Adressleitungen hoch stecken. Das funktioniert am besten
mit physischer Speicheradressierung jedoch, diese auszuüben
virtuelle Adressen haben auch einen gewissen Wert.
write64 schreibt sequentiell in den Speicher mit 32 x 64-Bit-Schreibvorgängen pro Bogo
Schleife. Jede Schleife entspricht einer Bogo-Operation. Dies
Übungen Rohgedächtnis schreibt. Beachten Sie, dass Speicherschreibvorgänge
nicht am Ende jeder Testiteration überprüft.
null-eins setzt alle Speicherbits auf null und prüft dann, ob irgendwelche Bits vorhanden sind
nicht null. Setzen Sie als nächstes alle Speicherbits auf eins und prüfen Sie, ob
irgendwelche Bits sind nicht eins.

--vm-populate
(Voreinstellungs-)Seitentabellen für die Speicherzuordnungen auffüllen; dies kann den Austausch stressen.
Nur auf Systemen verfügbar, die MAP_POPULATE unterstützen (seit Linux 2.5.46).

--vm-rw N
Starten Sie N Worker, die Speicher zu/von einem Elternteil/Kind übertragen, indem Sie verwenden
Process_vm_writev(2) und process_vm_readv(2). Diese Funktion wird nur unterstützt auf
Linux. Speicherübertragungen werden nur überprüft, wenn die Option --verify aktiviert ist.

--vm-rw-ops N
Stoppen Sie die vm-rw-Worker nach N Lese-/Schreibvorgängen im Speicher.

--vm-rw-bytes N
mmap N Byte pro vm-rw-Worker, der Standardwert ist 16 MB. Man kann die Größe in angeben
Einheiten von Bytes, KBytes, MBytes und GBytes mit dem Suffix b, k, m oder g.

--vm-spleiß N
Verschieben Sie Daten aus dem Speicher nach /dev/null durch eine Pipe, ohne zwischendurch zu kopieren
Kernel-Adressraum und Benutzer-Adressraum mit vmsplice(2) und spleißen(2). Dies
ist nur für Linux verfügbar.

--vm-splice-ops N
Stoppen Sie nach N bogo VM-Splice-Operationen.

--vm-spleißbytes N
N Byte pro vmsplice-Aufruf übertragen, der Standardwert ist 64 KB. Man kann die Größe in angeben
Einheiten von Bytes, KBytes, MBytes und GBytes mit dem Suffix b, k, m oder g.

--Warten N
Starte N Arbeiter, die zwei Kinder hervorbringen; man dreht sich in a Pause(2) Schleife, die
andere stoppt kontinuierlich und setzt die erste fort. Der Kontrollprozess wartet auf
das erste Kind, das nach der Geburt von SIGCONT wieder aufgenommen wird, unter Verwendung von wartepid(2) und
warte(2).

--wait-ops N
Stoppen Sie nach N Bogo-Wartevorgängen.

--WC N
Starte N Worker, die verschiedene libc-Funktionen für breite Zeichenfolgen ausüben auf
zufällige Zeichenfolgen.

--wcs-Methode wcsfunkt
Wählen Sie eine bestimmte libc-weite Zeichenkettenfunktion aus, die Sie betonen möchten. Verfügbare Saite
zu betonende Funktionen sind: all, wcscasecmp, wcscat, wcschr, wcscoll, wcscmp, wcscpy,
wcslen, wcsncasecmp, wcsncat, wcsncmp, wcsrchr und wcsxfrm. Die 'alle'-Methode ist
die Standardeinstellung und wird alle String-Methoden ausführen.

--wcs-ops N
Stoppen Sie nach N bogo breiten Zeichenkettenoperationen.

--xattr N
Starten Sie N Arbeiter, die Stapel von erweiterten Attributen auf einem erstellen, aktualisieren und löschen
Datei.

--xattr-ops N
Stoppen Sie nach N bogo erweiterten Attributoperationen.

-y N, --Ertrag N
Starte N Arbeiter die anrufen geplante Ausbeute(2). Dieser Stressor stellt sicher, dass mindestens 2
untergeordnete Prozesse pro CPU-Übung schild_ertrag(2) egal wie viele Arbeiter sind
spezifiziert, wodurch immer ein schneller Kontextwechsel gewährleistet ist.

--Yield-Ops N
Stoppen Sie Ertragsstressarbeiter nach N geplante Ausbeute(2) Bogo-Operationen.

--Null N
Starte N Arbeiter mit dem Lesen von /dev/zero.

--zero-ops N
Stoppen Sie Zero-Stress-Worker nach N /dev/zero bogo-Leseoperationen.

--zlib N
Starten Sie N Arbeiter, die zufällige Daten mit zlib komprimieren und dekomprimieren. Jeder Arbeiter
hat zwei Prozesse, einen, der zufällige Daten komprimiert und an einen anderen Prozess weiterleitet
das dekomprimiert die Daten. Dieser Stressor belastet CPU, Cache und Speicher.

--zlib-ops N
Stopp nach N Bogo-Kompressionsoperationen, jede Bogo-Kompressionsoperation ist a
Komprimierung von 64 KB Zufallsdaten auf der höchsten Komprimierungsstufe.

--Zombie N
Starten Sie N Arbeiter, die Zombie-Prozesse erstellen. Dies wird schnell versuchen, ein zu erstellen
Standardwert von 8192 untergeordneten Prozessen, die sofort sterben und in einem Zombie-Zustand warten
bis sie geerntet werden. Sobald die maximale Anzahl von Prozessen erreicht ist (oder fork
scheitert, weil man die maximal erlaubte Kinderzahl erreicht hat) der Älteste
das Kind geerntet und dann ein neuer Prozess nach dem First-in-First-out-Prinzip erstellt wird,
und dann wiederholt.

--Zombie-Ops N
Stoppen Sie Zombie-Stressarbeiter nach N-Bogo-Zombie-Operationen.

--zombie-max N
Versuchen Sie, so viele wie N Zombie-Prozesse zu erstellen. Dies kann möglicherweise nicht erreicht werden, wenn das System
Grenze ist kleiner als N.

Beispiele:

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

läuft 60 Sekunden lang mit 4 CPU-Stressoren, 2 IO-Stressoren und 1 VM-Stressor unter Verwendung von
1 GB virtueller Speicher.

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

führt 8 CPU-Stressoren aus und stoppt nach 800000 Bogo-Operationen.

stress-ng --sequentiell 2 --timeout 2m --metrics

Führen Sie 2 gleichzeitige Instanzen aller Stressoren nacheinander aus, jeweils für
2 Minuten und fassen Sie am Ende mit Leistungskennzahlen zusammen.

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

4 FFT-CPU-Stressoren ausführen, nach 10000 Bogo-Operationen stoppen und eine Zusammenfassung erstellen
nur für die FFT-Ergebnisse.

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

CPU-Stressoren auf allen Online-CPUs ausführen, die durch alle verfügbaren CPUs arbeiten
Stressoren für 1 Stunde.

stress-ng --all 4 --timeout 5m

Führen Sie 4 Instanzen aller Stressoren für 5 Minuten aus.

stress-ng --zufällig 64

Lassen Sie 64 Stressoren laufen, die zufällig aus allen verfügbaren Stressoren ausgewählt werden.

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

Führen Sie 64 Instanzen aller verschiedenen CPU-Stressoren aus und überprüfen Sie, ob die
Berechnungen sind für 10 Minuten korrekt, mit einer Zusammenfassung der Bogo-Operationen am Ende.

stress-ng --sequentiell 0 -t 10m

Lassen Sie alle Stressoren 10 Minuten lang nacheinander laufen, mit der Anzahl der Instanzen von
jeder Stressor entspricht der Anzahl der Online-CPUs.

stress-ng --sequentiell 8 --class io -t 5m --mal

Alle Stressoren in der io-Klasse nacheinander für jeweils 5 Minuten mit 8 . laufen
Instanzen jedes Stressors, die gleichzeitig ausgeführt werden, und zeigen die Gesamtzeitnutzung an
Statistik am Ende des Laufs.

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

Führen Sie alle Stressoren (jeweils 1 Instanz pro CPU) gleichzeitig aus, maximieren Sie die
Einstellungen (Speichergrößen, Dateizuordnungen usw.) und wählen Sie die meisten
anspruchsvolle/aggressive Optionen.

stress-ng --random 32 -x numa,festplatte,schlüssel

Führen Sie 32 zufällig ausgewählte Stressoren aus und schließen Sie die Numa-, HDD- und Schlüsselstressoren aus

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

4 Instanzen der VM-Stressoren nacheinander ausführen, den Bigheap ausgenommen,
brk- und Stack-Stressoren

EXIT STATUS

Status Beschreibung
0 Erfolg.
1 Fehler; falsche Benutzeroptionen oder ein fatales Ressourcenproblem im Stress-ng
Stressor-Harness (zum Beispiel aus dem Gedächtnis).
2 Ein oder mehrere Stressoren sind ausgefallen.
3 Ein oder mehrere Stressoren konnten aufgrund fehlender Ressourcen nicht initialisiert werden, z
Beispiel ENOMEM (kein Speicher) und ENOSPC (kein Speicherplatz auf Dateisystem).

Verwenden Sie stress-ng online mit den onworks.net-Diensten