ストレスNG - クラウドでオンライン

プログラム：

NAME

tress-ng - コンピュータ システムに負荷をかけてストレスを与えるツール

SYNOPSIS

ストレス-ng [オプション [ARG]]..。

DESCRIPTION

tress-ng は、選択可能なさまざまな方法でコンピュータ システムのストレス テストを行います。 設計されました
コンピュータのさまざまな物理サブシステムやさまざまな操作を実行するため
システムカーネルインターフェイス。 tress-ng には、幅広い CPU 固有のストレス テストもあります
浮動小数点、整数、ビット操作、および制御フローを実行します。

tress-ng は元々、マシンを激しく動作させ、ハードウェアの問題を引き起こすことを目的としていました。
熱オーバーランや、システムが故障している場合にのみ発生するオペレーティング システムのバグなど。
激しく叩きつけられる。 一部のテストではシステムが実行される可能性があるため、stress-ng の使用には注意が必要です。
設計が不十分なハードウェアでは熱が発生し、過度のシステム スラッシングが発生する可能性があります。
止めるのが難しい。

tress-ng はテストのスループット レートも測定できます。 これは観察するのに役立ちます
オペレーティング システムのリリースやハードウェアの種類が異なると、パフォーマンスが変化します。
ただし、正確なベンチマーク テスト スイートとして使用することは決して意図されていないため、
このような方法で使用しないでください。

root 権限でストレス ng を実行すると、Linux システムのメモリ不足設定が調整されます
メモリ不足の状況でストレッサーを強制終了できないようにするため、これを慎重に使用してください。 と
適切な特権、stress-ng を使用すると、イオンクラスとイオンレベルを次のように設定できます。
調整済みですが、これは注意して使用する必要があります。

ストレス テストの種類ごとに呼び出すプロセスの数を指定できます。 を指定する
負の値またはゼロの値は、次の定義に従って使用可能なプロセッサの数を選択します。
sysconf(_SC_NPROCESSORS_CONF)。

OPTIONS

全般 ストレス-ng コントロール オプション：

- 攻撃的
より多くのファイル、キャッシュ、メモリの積極的なオプションを有効にします。 これによりテストが遅くなる可能性があります。
レイテンシーを増やし、ボゴオペレーションの数を減らすだけでなく、
ストレス要因の種類に応じて使用されるユーザー時間とシステム時間のバランス
中古。

-a N, - すべて N
各ストレッサーの N 個のインスタンスを開始します。 N が XNUMX 未満の場合、CPU の数
online はインスタンスの数に使用されます。 N がゼロの場合、CPU の数
システム内で使用されます。

-b N, --バックオフ N
各ストレス ワーカー プロセスの開始の間に N マイクロ秒待機します。 これにより、
XNUMXつはストレステストを時間の経過とともに強化することです。

- クラス 名
実行するストレッサーのクラスを指定します。 ストレス要因は次の XNUMX つ以上に分類されます。
次のクラス: cpu、cpu-cache、device、io、interrupt、filesystem、memory、
ネットワーク、OS、パイプ、スケジューラー、VM。 ストレス要因の中には、XNUMX つのクラスに分類されるものもあります。 のために
たとえば、「get」ストレッサーは単に「os」クラス内にあります。 その他のストレス要因は以下に該当します
複数のクラス。たとえば、「lsearch」ストレッサーは「cpu」に分類されます。
「cpu-cache」クラスと「memory」クラスは、これら XNUMX つすべてを実行します。 を選択する
特定のクラスは、実行時にのみそのクラスに分類されるすべてのストレッサーを実行します。
--sequential オプションを使用します。

-NS、 -ドライラン
オプションを解析しますが、ストレス テストは実行しません。 ノーオペです。

-NS、 - 助けて
ヘルプを表示します。

--ignite-cpu
カーネル制御を変更して CPU を最大化しようとします。 これには root 権限が必要です
いろいろ変える / sys インターフェースコントロール。 現在、これは Intel P-State でのみ機能します
Linux 上で x86 システムを有効にしました。

--ionice クラス class
ionice クラスを指定します (Linux のみ)。 アイドル (デフォルト)、ベストエフォート、be、
リアルタイム、RT。

--ionice-レベル レベル
ionice レベルを指定します (Linux のみ)。 アイドルの場合、可能なオプションは 0 のみです。 のために
besteffort またはリアルタイム値 0 (最高の優先順位) ～ 7 (最低の優先順位)。 見る
イオニス（1）詳細については。

-k、 --キープ名
デフォルトでは、stress-ng はストレス プロセスの名前を変更しようとします。
機能に応じて。 このオプションはこれを無効にし、プロセスを維持します
names は親プロセスの名前 (stress-ng) になります。

--ログブリーフ
デフォルトでは、stress-ng はプログラムの名前、メッセージの種類、および
プロセス ID をすべての出力のプレフィックスとして使用します。 --log-brief オプションはメッセージを出力します
これらのフィールドを省略すると、冗長性の低い出力が生成されます。

-ログファイル ファイル名
指定されたログ ファイルにメッセージを書き込みます。

-最大化
デフォルトのストレッサー設定をオーバーライドし、代わりにこれらを最大値に設定します。
設定が許可されます。 これらのデフォルトは、ストレッサーごとにいつでも上書きできます。
必要に応じて設定オプションを選択します。

-メトリクス
ストレス プロセスによって実行されたボゴ操作の合計数を出力します。 注記
これらはパフォーマンスやスループットの信頼できる指標ではなく、まだ確立されていないこと
あらゆるベンチマークに使用できるように設計されています。 指標は単なる便利な方法です
さまざまな種類の負荷がかかったときにシステムがどのように動作するかを観察します。

次の情報列が出力されます。

コラム 見出し 説明
bogo ops 実行中のストレッサーの反復回数。
これは、全体的な「作業」の量を示す指標です。
ボゴ作戦で達成。
リアルタイム (秒) の平均実時間 (秒単位)
ストレス要因。 これは、すべての時間の合計です。
特定のストレス要因のインスタンスを
実行されているこれらのストレッサーの数。
ユーザー時間 (秒) すべての実行に消費された合計ユーザー時間 (秒単位)
ストレッサーの例。
sys time (secs) すべてのシステムの実行に消費された合計システム時間 (秒単位)
ストレッサーの例。
bogo ops/s (リアルタイム) 実時間の実行に基づく XNUMX 秒あたりの合計 bogo オペレーション
時間。 実測時間は見かけの走行を反映しています
時間。 システム上のプロセッサの数が増えるほど、
作業負荷をこれらに分散できるため、
実測時間が短縮され、ボゴオペレーションレートが低下します
増加します。 これは本質的に「見かけ上の」ボゴです
システムの運用速度。

bogo ops/s (usr+sys time) 累計に基づく XNUMX 秒あたりの合計 bogo オペレーション
ユーザー時間とシステム時間。 これは実際の bogo ops レートです
実時間を考慮したシステム
すべてのストレッサーの実行時間
プロセッサー。 通常、これは追加するにつれて減少します
キャッシュ上の競合による同時ストレス要因の増加、
メモリ、実行ユニット、バス、I/O デバイス。

--メトリクスの概要
メトリクスを有効にし、ゼロ以外のメトリクスのみを出力します。

--最小化する
デフォルトのストレッサー設定をオーバーライドし、代わりにこれらを最小値に設定します。
設定が許可されます。 これらのデフォルトは、ストレッサーごとにいつでも上書きできます。
必要に応じて設定オプションを選択します。

--ノーアドバイス
バージョン 0.02.26 以降、stress-ng は自動的に呼び出します マバイス(2) ランダムなアドバイス付き
各 mmap および munmap の前にオプションを追加すると、vm サブシステムに少しだけ負荷がかかります。
--no-advise オプションは、このデフォルトをオフにします。

--ページイン
コアにない割り当てられたページにタッチし、それらのページを強制的にページインさせます。
を使用するときに、割り当てられたすべてのページを強制的にページインする便利なオプションです。
bigheap、mmap、および vm ストレッサー。 パフォーマンスが大幅に低下します。
システム内のメモリが、割り当てられたバッファ サイズよりも小さいです。 これは、 ミンコア(2)
コアにないページを判断し、ページングするにはタッチする必要があります。
戻る。

--病的
システムを停止させることが知られているストレッサーを有効にします。 一部のストレス要因はすぐに
システムが停止する前に急速にシステムをハングさせるような方法でリソースを消費します。
カーネルはそれらを OOM で強制終了できます。 これらのストレス要因はデフォルトでは有効になっていません。このオプションは
それらを有効にしますが、おそらくこれを実行したくないでしょう。 あなたは警告を受けました。

--perf perf イベントを使用してプロセッサーとシステムのアクティビティを測定します。 Linux のみおよび注意事項
エンターによると perf_event_open(2): 「結果は必ず再確認してください!
一般化された出来事には間違った価値観があった。」

-NS、 - 静かな
出力は表示されません。

-r N, - ランダム N
N 個のランダムなストレス ワーカーを開始します。 N が 0 の場合、構成されたプロセッサの数
Nに使用されます。

--スケジュール スケジューラ
名前付きスケジューラを選択します (Linux のみ)。 使用可能なスケジューラのリストを表示するには
使用：stress-ng --sched

--sched-prio プリオ
スケジューラの優先順位レベルを選択します (Linux のみ)。 スケジューラがそうでない場合は、
これをサポートする場合は、デフォルトの優先レベル 0 が選択されます。

- 一連 N
すべてのストレッサーをデフォルトの 60 秒間 XNUMX つずつ順番に実行します。 の
開始される個々のストレッサーのインスタンスの数は N です。N がそれより小さい場合
ゼロより大きい場合は、オンラインの CPU の数がインスタンスの数として使用されます。 もし
N がゼロの場合、システム内の CPU の数が使用されます。 --timeout オプションを使用する
各ストレッサーを実行する時間を指定します。

--syslog
syslog へのログ出力 (詳細な -v メッセージを除く)。

--一時パス path
tress-ng 一時ディレクトリと一時ファイルのパスを指定します。 デフォルト
path は現在の作業ディレクトリです。 このパスには読み取りおよび書き込みアクセスが必要です
ストレス-NG ストレスプロセス用。

-t N, - タイムアウト N
N 秒後にストレス テストを停止します。 時間の単位を指定することもできます。
秒、分、時間、日、または年に接尾辞 s、m、h、d、または y を付けます。

--タイマーの余裕 N
プロセスごとのタイマーのスラックを N ナノ秒に調整します (Linux のみ)。 増加する
タイマー スラックを使用すると、カーネルがいくつかのあいまいさを追加することでタイマー イベントを結合できるようになります。
タイマーの有効期限が短縮され、ウェイクアップが減少します。 逆にタイマーを減らす
たるみが起きやすくなります。 タイマースラックの値を 0 にすると、システムが設定されます。
デフォルトは 50,000 ナノ秒です。

-回
終了時のすべての子プロセスの累積ユーザー時間とシステム時間を表示します。
ストレスが走ります。 利用可能な CPU 時間の使用率も
システム内のオンライン CPU の数から計算されます。

--tz マシン上の利用可能なサーマル ゾーンから温度を収集します (Linux のみ)。
一部のデバイスには XNUMX つ以上のサーマル ゾーンがある場合がありますが、その他のデバイスにはサーマル ゾーンがない場合があります。

-v、 -詳細
すべてのデバッグ、警告、および通常の情報出力を表示します。

- 確認
テストの実行時に結果を確認します。 これはすべてのテストで利用できるわけではありません。 この意志
テスト実行からの計算またはメモリの内容を健全性チェックし、レポートします。
stderr 予期しない障害。

-V、 - バージョン
バージョンを表示します。

-NS、 -除外する リスト
除外する (つまり、実行しない) XNUMX つ以上のストレッサーのリストを指定します。
これは、実行するストレッサーを多数選択する場合に、特定のストレッサーを除外するのに役立ちます。
--class オプション、--sequential、--all、および --random オプションを使用します。 例、実行
CPU クラスのストレッサーを同時に処理し、NUMA および検索ストレッサーを除外します。

ストレス-ng --class cpu --all 1 -x uma、bsearch、hsearch、lsearch

-Y、 --yaml ファイル名
収集した統計を「filename」という名前の YAML 形式のファイルに出力します。

ストレス要因 特定の オプション：

-アフィニティ N
CPU アフィニティを急速に変更する N 個のワーカーを開始します (Linux のみ)。 高速切り替え
CPU アフィニティは、キャッシュ動作の低下に寄与する可能性があります。

--アフィニティ-ops N
N bogo アフィニティ操作後にアフィニティ ワーカーを停止します (Linux のみ)。

--アフィニティランド
CPU アフィニティをデフォルトの順次ではなくランダムに切り替えます。

--af-alg N
さまざまなサイズのハッシュを使用して AF_ALG ソケット ドメインを実行する N 個のワーカーを開始します
SHA1、SHA224、SHA256、SHA384、SHA512、MD4、MD5、RMD128、を使用したランダム メッセージ
RMD160、RMD256、RMD320、WP256、WP384、WP512、TGR128、TGR160、および TGR192 ハッシュ。
（Linuxのみ）。

--af-alg-ops N
N 個の AF_ALG メッセージがハッシュされた後に af-alg ワーカーを停止します。

--aio N
複数の小規模な非同期 I/O の書き込みと読み取りを発行する N 個のワーカーを開始します。
POSIX aio インターフェイスを使用した比較的小さな一時ファイル。 これだけで当たるよ
ファイル システム キャッシュは、発行時にユーザーとカーネルの時間を多く消費します。
I/O リクエストの処理。 デフォルトでは、各ワーカー プロセスは 16 個の同時処理を処理します。
I/O リクエスト。

--aio-ops N
N bogo の非同期 I/O 要求後に POSIX 非同期 I/O ワーカーを停止します。

--aio-requests N
各ワーカーが発行する POSIX 非同期 I/O リクエストの数を指定します。
デフォルトは 16 です。 1 ～ 4096 を使用できます。

--アイオル N
を使用して複数の 4K ランダムな非同期 I/O 書き込みを発行する N 個のワーカーを開始します。
Linux aio システムコール io_setup（2） io_submit（2） io_getevents（2）と
io_destroy(2)。 デフォルトでは、各ワーカー プロセスは 16 個の同時 I/O を処理します。
リクエスト。

--aiol-ops N
N bogo の非同期 I/O リクエスト後に Linux 非同期 I/O ワーカーを停止します。

--aiol-requests N
各ワーカーが発行する Linux 非同期 I/O リクエストの数を指定します。
デフォルトは 16 です。 1 ～ 4096 を使用できます。

-- 防具 N
AppArmor インターフェイスのさまざまな部分を実行する N 個のワーカーを開始します。 現在
この特定のテストを実行するには root 権限が必要です。 このテストはのみ利用可能です
AppArmor をサポートする Linux システム上。

--apparmor-ops
N bogo 操作後に AppArmor ワーカーを停止します。

-B N, --bigheap N
メモリを再割り当てすることでヒープを拡大する N 個のワーカーを開始します。 メモリ不足の場合
Linux 上のキラー (OOM) はワーカーを強制終了するか、割り当てが失敗して割り当てが失敗します。
プロセスが最初からやり直しになります。 ワーカーの OOM 調整が設定されていることに注意してください
そのため、OOM キラーはこれらのワーカーを最初の候補プロセスとして扱います。
殺します。

--bigheap-ops N
N 個の bogo 割り当て操作が完了した後、大きなヒープ ワーカーを停止します。

--bigheap-growth N
反復ごとにヒープを拡大するメモリ量を指定します。 サイズは 4K から
64MB。 デフォルトは64Kです。

--バインドマウント N
ユーザー名前空間内の mount / を / に繰り返しバインドする N 個のワーカーを開始します。 これはできる
リソースを急速に消費し、メモリ不足の状況を強制します。 これは使用しないでください
マシンをハングさせる危険を冒したくない場合を除き、ストレス要因となります。

--バインドマウントオプス N
N バインドマウントボゴ操作後に停止します。

--brk N
複数のデータを使用して一度に XNUMX ページずつデータ セグメントを拡大する N 個のワーカーを開始します。
BRK(2) 電話をかける。 正常に割り当てられた新しいページはそれぞれ、確実に割り当てられるようにタッチされます。
記憶の中の住人。 メモリ不足状態が発生すると、テストはリセットされます
データセグメントを開始前のポイントまで戻し、データセグメントを繰り返す
再度サイズ変更中。 プロセスは、メモリ不足の設定を調整して、
他のプロセスの前にメモリ不足 (OOM) キラーによって強制終了されます。 もしそれが
OOM キラーによって強制終了された場合、監視によって自動的に再起動されます。
親プロセス。

--brk-ops N
N ボゴ brk 操作後に brk 労働者を停止します。

--brk-notouch
新しく割り当てられた各データ セグメント ページには触れないでください。 これにより、デフォルトの
新しく割り当てられた各ページにアクセスするため、カーネルが必ずしも
ページを実際の物理メモリでバックアップします。

--bsearch N
を使用して、ソートされた 32 ビット整数の配列をバイナリ検索する N 個のワーカーを開始します。
bサーチ(3)。 デフォルトでは、配列には 65536 個の要素があります。 これは便利です
メモリとプロセッサ キャッシュのランダム アクセスを実行する方法。

--bsearch-ops N
N bogo bsearch 操作が完了した後、bsearch ワーカーを停止します。

--bsearch-size N
bsearchに配列のサイズ(32ビット整数の数)を指定します。 サイズは
1Kから4Mまで。

-C N, - キャッシュ N
ランダムなワイドスプレッドメモリの読み取りとスラッシュへの書き込みを実行する N 個のワーカーを開始します
CPU キャッシュ。 コードは CPU キャッシュをインテリジェントに決定しません
構成が異なるため、読み取り/書き込みのヒットミスを発生させるには最適ではない可能性があります。
一部のプロセッサのアクティビティ。

--キャッシュフェンス
各ストア操作で書き込みシリアル化を強制します (x86 のみ)。 これはノーオペです
非 x86 アーキテクチャ。

--キャッシュフラッシュ
各ストア操作でキャッシュを強制的にフラッシュします (x86 のみ)。 これは非 x86 では何も行われません。
アーキテクチャ。

--キャッシュレベル N
実行するキャッシュのレベルを指定します (1=L1 キャッシュ、2=L2 キャッシュ、3=L3/LLC キャッシュ (
デフォルト））。 キャッシュ階層を決定できない場合は、組み込みのデフォルトが使用されます。
が適用されます。

--キャッシュなしアフィニティ
次の場合はプロセッサ アフィニティを変更しないでください。 - キャッシュ 有効です。

--キャッシュ操作 N
N 回の bogo キャッシュ スラッシュ操作後にキャッシュ スラッシュ ワーカーを停止します。

--キャッシュプリフェッチ
プリフェッチをサポートするアーキテクチャ上の次の読み取りアドレスで読み取りプリフェッチを強制します。

--キャッシュ方法 N
実行するキャッシュウェイの数を指定します。 これにより、全体のサブセットが可能になります。
実行されるキャッシュ サイズ。

- キャップ N
への呼び出しを介してプロセスごとの機能を読み取る N 個のワーカーを開始します キャプゲット(2) (Linux
のみ）。

--cap-ops N
N キャップボゴ操作後に停止します。

--chdir N
を使用して 8192 ディレクトリ間でディレクトリを変更する N 個のワーカーを開始します Chdirとします。

--chdir-ops N
N chdir bogo 操作後に停止します。

--chmod N
ファイル モード ビットを変更する N 個のワーカーを開始します。 chmod（2）と fchmod（2）
同じファイル。 N の値が大きいほど、単一ファイルの競合が多くなります。
ストレッサーは、モード ビットのすべての組み合わせを通じて機能します。

--chmod-ops N
N chmod bogo 操作後に停止します。

- 時計 N
N 個のワーカーがクロックと POSIX タイマーを実行するように開始します。 既知のすべてのクロック タイプについて、これは
運動します クロックゲットレス（2） クロック_ゲットタイム（2）と クロックナノスリープ(2)。 すべてのために
既知のタイマーでは 50000ns タイマーが作成され、期限切れになるまでビジーポーリングが行われます。
このストレス要因により、コンテキストの切り替えが頻繁に発生します。

--クロックオペレーション N
N bogo 操作後にクロック ストレス ワーカーを停止します。

- クローン N
クローンを作成する N 個のワーカーを開始します ( (2) システムコール)。 この意志
即座に停止して待機するデフォルトの 8192 クローンを迅速に作成しようとします。
収穫するまでゾンビ状態。 クローンの最大数に達すると
(または、許可される最大値に達したためにクローンが失敗します) 最も古いクローン
スレッドが刈り取られ、新しいクローンが先入れ先出し方式で作成されます。
そしてそれを繰り返しました。 ランダムなクローン フラグが、試行するクローンごとに選択されます。
さまざまなクローン操作を実行します。 クローン ストレッサーは Linux のみのオプションです。

--clone-ops N
N bogo クローン操作後にクローン ストレス ワーカーを停止します。

--クローンマックス N
N 個までのクローン スレッドを作成してみてください。 システムが次の場合にはこの値に達しない可能性があります。
制限は N 未満です。

- 環境 N
を使用する XNUMX つのスレッドを実行する N 個のワーカーを開始します。 スワップコンテキスト(3) を実装する
スレッド間のコンテキスト切り替え。 これにより、プロセスのコンテキストが迅速に保存され、
帯域幅はレジスタとメモリの保存および復元速度によって制限されます。

--context-ops N
N 個の bogo コンテキスト切り替え後に N 個のコンテキスト ワーカーを停止します。 このストレッサーでは、1 ボゴ オペレーション
これは、1000 回の swapcontext 呼び出しに相当します。

--コピーファイル N
Linux を使用してファイルをコピーする N 個のストレッサーを開始します。 コピーファイル範囲（2）システムコール。
2MB のデータ チャンクがランダムな場所から XNUMX つのファイルにコピーされます。
場所を宛先ファイルにコピーします。 デフォルトでは、ファイルのサイズは 256 MB です。 データは
毎回の後にファイルシステムに同期されます コピーファイル範囲（2）電話します。

--コピーファイル操作 N
N回のcopy_file_range()呼び出し後に停止します。

--コピーファイルバイト N
コピーファイルのサイズ、デフォルトは 256 MB です。 サイズはバイト単位で指定できます。
接尾辞 b、k、m、または g を使用した KBytes、MBytes、GBytes。

-c N, - CPU N
すべての処理を順番に処理することで、CPU を実行する N 個のワーカーを開始します。
さまざまな CPU ストレス方法。 すべての CPU ストレス手法を実行する代わりに、
--cpu-method オプションを使用して、特定の CPU ストレス方法を指定できます。

--cpu-ops N
N bogo 操作後に CPU ストレス ワーカーを停止します。

-l P, --cpu-load P
CPU にストレスを感じるワーカー向けに、P パーセントの負荷で CPU を負荷します。 0 は事実上
スリープ (負荷なし)、100 はフル負荷です。 読み込みループがコンピューティングに分割される
時間 (負荷%) とスリープ時間 (100% - 負荷%)。 精度は全体の負荷に依存します。
プロセッサーとスケジューラーの応答性により異なるため、実際の負荷は次のようになります。
希望の負荷と異なる。 bogo CPU 操作の数は、
一部のシステムでは CPU 周波数スケーリングを採用しているため、負荷に応じて線形にスケーリングできません。
したがって、負荷が重くなると、CPU 周波数が増加し、CPU ボゴが大きくなります。
操作。

--cpu-load-slice S
注 - このオプションは、--cpu-load が 100% 未満の場合にのみ役立ちます。 CPU負荷
複数のビジーサイクルとアイドルサイクルに分かれています。 このオプションを使用して、
ビジータイムスライスの継続時間。 S の負の値は、
CPU をアイドル状態にする前に実行する反復 (例: -30 は CPU の 30 反復を呼び出します)
ストレスループ）。 値をゼロにすると、0 ～ 0.5 秒の間でランダムなビジー時間が選択されます。
S の正の値は、アイドル状態になる前に実行するミリ秒数を指定します。
CPU (例: 100 は CPU を 0.1 秒間ビジー状態に保ちます)。 小さな値を指定する
S は、タイム スライスを小さくし、よりスムーズなスケジューリングに役立ちます。 --cpu-load を
比較的低い値と --cpu-load-slice を大きくすると、次の間で CPU が循環されます。
アイドル状態とビジー状態のサイクルが長くなり、異なる CPU 周波数が使用されます。 サーマル
CPU の範囲も循環されるため、これは、
スケジューラ、周波数スケーリング、およびパッシブ/アクティブ熱冷却メカニズム。

--cpu-メソッド 方法
CPU ストレスメソッドを指定します。 デフォルトでは、すべてのストレスメソッドが実行されます。
ただし、必要に応じて、使用するメソッドを XNUMX つだけ指定することもできます。
利用可能な CPU ストレス方法は次のとおりです。

方法 詳細説明
すべては以下のすべての CPU ストレスメソッドを反復します
ackermann アッカーマン関数: A(3, 10) を計算します。ここで、
m = 1 の場合、A(m, n) = n + 0。
m > 1 および n = 1 の場合、A(m - 0, 0)。
m > 1 および n > 1 の場合、A(m - 0, A(m, n - 0))
bitops bithack からのさまざまなビット操作、つまりリバース ビット、パリティ
チェック、ビット数、最も近い 2 のべき乗に丸める
callfunc は、8 引数の C 関数を 1024 回の呼び出しの深さまで再帰的に呼び出します。
そしてリラックスしてください
cfloat 浮動小数点複素演算を組み合わせた 1000 回の反復
cdouble ダブル浮動小数点複素数の混合の 1000 回の反復
管理ツール
clongdouble long double 浮動小数点複素数の混合の 1000 回の反復
管理ツール
correlate ランダム double の 16384 × 1024 相関を実行します。
crc16 は、ランダム データに対して 1024 ラウンドの CCITT CRC16 を計算します。
32 進数 1000 32 ビット XNUMX 進浮動小数点を組み合わせた XNUMX 回の反復
操作 (GCC のみ)
64 進数 1000 64 ビット XNUMX 進浮動小数点を組み合わせた XNUMX 回の反復
操作 (GCC のみ)
128 進数 1000 128 ビット XNUMX 進浮動小数点を組み合わせた XNUMX 回の反復
操作 (GCC のみ)
dither 1024 ビットからの 768 × 8 ランダム画像の Floyd-Steinberg ディザリング
深さ1ビットまで。
djb2a 128 ラウンドのハッシュ DJB2a (xor を使用した Dan Bernstein ハッシュ)
バリアント) 128 ～ 1 バイトのランダム文字列
倍精度浮動小数点を組み合わせた 1000 回の繰り返し
管理ツール
オイラーは n = (1 + (1 ÷ n)) ↑ n を使用して e を計算します。
explog n = exp(log(n) ÷ 1.00002) で反復します。
fibonacci 0、1、1、2、5、8... のフィボナッチ数列を計算します。
fft 4096 サンプル高速フーリエ変換
float 浮動小数点演算を組み合わせた 1000 回の反復
fnv1a 128 ラウンドのハッシュ FNV-1a (xor を使用した Fowler-Noll-Vo ハッシュ)
乗算バリアント) 128 ～ 1 バイトのランダムな文字列
gamma は、制限を使用してオイラー・マスケローニ定数 γ を計算します。
高調波系列の差 (1 + 1/2 + 1/3 + 1/4 + 1/5)
... + 1/n) と自然対数 ln(n) (n = 80000 の場合)。
gcd 整数の GCD を計算します
グレー バイナリをグレー コードに計算し、グレー コードをバイナリに戻します。
0 ～ 65535 の整数
ハミング 8,4 個の 262144 ビット データに対してハミング H(4) コードを計算します。 これ
4 ビット データを 8 つのパリティ ビットを含む 4 ビット ハミング コードに変換します。
データ ビット d1..d4 の場合、パリティ ビットは次のように計算されます。
p1 = d2 + d3 + d4
p2 = d1 + d3 + d4
p3 = d1 + d2 + d4
p4 = d1 + d2 + d3
ハノイは、再帰的解法を使用して 21 枚のディスクのハノイの塔スタックを解きます。
float、double の場合、双曲線計算 sinh(θ) × cosh(θ) + sinh(2θ) + cosh(3θ)
θ = 0 の場合の長い二重双曲線サインおよびコサイン関数
2ステップで1500πまで
idct 8 × 8 IDCT (逆離散コサイン変換)
int8 1000 ビット整数演算を組み合わせた 8 回の反復
int16 1000 ビット整数演算を組み合わせた 16 回の反復
int32 1000 ビット整数演算を組み合わせた 32 回の反復
int64 1000 ビット整数演算を組み合わせた 64 回の反復

int128 1000 ビット整数演算を組み合わせた 128 回の反復 (GCC のみ)
int32float 1000 ビット整数と浮動小数点を組み合わせた 32 回の反復
管理ツール
int32double 1000 ビット整数と倍精度を組み合わせた 32 回の反復
浮動小数点演算
int32longdouble 1000 ビット整数と Long double の組み合わせの 32 回の反復
高精度浮動小数点演算
int64float 1000 ビット整数と浮動小数点を組み合わせた 64 回の反復
管理ツール
int64double 1000 ビット整数と倍精度を組み合わせた 64 回の反復
浮動小数点演算
int64longdouble 1000 ビット整数と Long double の組み合わせの 64 回の反復
高精度浮動小数点演算
int128float 1000 ビット整数と浮動小数点を組み合わせた 128 回の反復
操作 (GCC のみ)
int128double 1000 ビット整数と倍精度を組み合わせた 128 回の反復
浮動小数点演算 (GCC のみ)
int128longdouble 1000 ビット整数と Long double の組み合わせの 128 回の反復
高精度浮動小数点演算 (GCC のみ)
int128decmal32 1000 ビット整数と 128 ビット 32 進数を組み合わせた XNUMX 回の反復
浮動小数点演算 (GCC のみ)
int128decmal64 1000 ビット整数と 128 ビット 64 進数を組み合わせた XNUMX 回の反復
浮動小数点演算 (GCC のみ)
int128decmal128 1000 ビット整数と 128 ビット 128 進数を組み合わせた XNUMX 回の反復
浮動小数点演算 (GCC のみ)
jenkin 128..128 バイトのランダム データの 1 ラウンドに対するジェンキンの整数ハッシュ
jmp 最適化されていない単純な比較 >、<、== および jmp 分岐
ln2 コンピューティング ln(2) シリーズに基づく:
1 - 1/2 + 1/3 - 1/4 + 1/5 - 1/6 ...
longdouble 長倍精度浮動小数点を組み合わせた 1000 回の反復
管理ツール
単純な空のループをループする
mathprod double float の 128 つの 128 × XNUMX 行列の行列積。 テスト
64 ビット x86 ハードウェアでは、これが次の機能を適切に組み合わせて提供されることがわかります。
メモリ、キャッシュ、浮動小数点演算であり、おそらく
CPU をホットに動作させるために使用する最適な CPU 方法。
nsqrt ニュートン・ラフソンを使用してlong doubleのsqrt()を計算します
omega 効率的な関数を使用して、Ωe↑Ω = 1 で定義されるオメガ定数を計算します。
Ωn+1 = (1 + Ωn) / (1 + e↑Ωn) の反復
パリティ スタンフォード ビットからのさまざまな方法を使用してパリティを計算します。
いじくりハック。 使用される方法は次のとおりです: 素朴な方法、素朴な方法
ブライアン・カーニガンによるビットカウントの最適化と同様に、
乗算方法、並列方法、およびルックアップ テーブル方法 (2
バリエーション）。
phi は系列を使用して黄金比 ϕ を計算します
pi Srinivasa Ramanujan 高速収束アルゴリズムを使用して π を計算します。
pjw 128 バイトのランダムなハッシュ pjw 関数を 128 ラウンド
ストリング
素数 わずかな値を使用して、1..1000000 の範囲内のすべての素数を検索します。
最適化されたブルート フォース ナイーブ トライアル分割検索
psi は、次の合計を使用して ψ (逆数フィボナッチ定数) を計算します。
フィボナッチ数の逆数
queens は、古典的な 8 queens 問題のすべての解を計算します。
ボードサイズ 1..12
rand rand() の 16384 回の繰り返し。rand は MWC 擬似ランダムです。
数値ジェネレーター。 MWC ランダム関数は 16 つの XNUMX ビットを連結します。
キャリー付き乗算ジェネレーター:
x(n) = 36969 × x(n - 1) + キャリー、
y(n) = 18000 × y(n - 1) + キャリー mod 2 ↑ 16

周期は約 2 ↑ 60 です
rand48 16384 回の反復 ドランド48（3）と ランド48(3)
rgb RGB を YUV に変換し、再び RGB に変換します (CCIR 601)
sdbm 128 ラウンドのハッシュ sdbm (SDBM データベースおよび GNU awk で使用される)
128 ～ 1 バイトのランダムな文字列
sieve のふるいを使用して、1..10000000 の範囲内の素数を見つけます。
エラトステネス
sqrt compute sqrt(rand())、ここで rand は MWC 擬似乱数です
ジェネレータ

trig float、double、および float の sin(θ) × cos(θ) + sin(2θ) + cos(3θ) を計算します。
長い二重サインおよびコサイン関数 (θ = 0 ～ 2π (1500 年))
ステップ
Union は、C 共用体のビット フィールドの混合に対して整数演算を実行します。
これは、コンパイラと CPU が整数をどの程度うまく実行できるかをテストします。
ビットフィールドのロードとストア。
ゼータ s = 2.0..10.0 のリーマン ゼータ関数 ζ(s) を計算します。

これらのメソッドの一部は、次のような計算で CPU を実行しようとすることに注意してください。
実際の使用例をいくつか紹介します。 ただし、コードは個別に最適化されていません。
アーキテクチャに基づいているため、手動で最適化されたコードと比較すると最適化されていない可能性があります。
いくつかのアプリケーション。 これらは、次のような典型的な命令の組み合わせを表現しようとしています。
これらのユースケース。

--cpu-オンライン N
ランダムに選択された CPU をオフラインおよびオンラインにする N 個のワーカーを開始します。 この Linux のみ
ストレッサーがこのアクションを実行するには root 権限が必要です。

--cpu-オンライン-ops N
オフライン/オンライン操作後に停止します。

--crypt N
を使用して 16 文字のランダムなパスワードを暗号化する N 個のワーカーを開始します。 陰窩（3） の
パスワードは、MD5、SHA-256、および SHA-512 暗号化方式を使用して暗号化されます。

--crypt-ops N
N 回の bogo 暗号化操作後に停止します。

- デーモン N
N 個のワーカーを開始し、それぞれがデーモンを作成します。デーモンは作成直後に終了します。
別のデーモンなど。 これは、プロセス テーブルを効果的に処理します。
親を持たず、init によって待機される存続期間の短いプロセス。 これ
子を迅速に刈り取るように init に圧力をかけます。 デーモンプロセスは以下を実行します。
通常の呼び出しを組み合わせて典型的な UNIX デーモンに変換するため、これは人為的に模倣します。
デーモン システムに非常に大きなストレスがかかります。

--デーモン-ops N
N 個のデーモンが作成された後、デーモン ワーカーを停止します。

-D N, --デントリー N
ディレクトリエントリを作成および削除する N 個のワーカーを開始します。 これによりファイルが作成されるはずです
システムメタデータアクティビティ。 ディレクトリエントリ名の末尾にはグレーコードが付けられます。
エンコードされた数値を使用して、名前空間のハッシュを混同しようとします。

--dentry-ops N
N bogo dentry 操作後に denty スラッシュワーカーを停止します。

--dentry-order [ フォワード | 逆 | ストライド | ランダム ]
dentry のリンク解除順序を指定します。順方向、逆方向、ストライド、またはランダムのいずれかになります。
デフォルトでは、dentry はランダムな順序でリンク解除されます。 転送注文のリンクが解除されます
最初から最後まで、逆の順序で最後から最初までリンクを解除します。ストライドします。
order は、準ランダムなパターンで order を段階的に実行することで、それらのリンクを解除します。
ランダム順序は、順方向、逆方向、またはストライド順序のいずれかをランダムに選択します。

--デントリー N
dentry スラッシング ループごとに N dentry を作成します。デフォルトは 2048 です。

--ディレクトリ N
mkdir と rmdir を使用してディレクトリを作成および削除する N 個のワーカーを開始します。

--dir-ops N
N bogo ディレクトリ操作後にディレクトリ スラッシュ ワーカーを停止します。

--dup N
実行する N 個のワーカーを開始します DUP(2) そしてそれから 閉じる(2) /dev/zero に対する操作。 の
一度に開く最大数はシステムで定義されているため、テストはこの値まで実行されます
最大数、または 65536 個のオープン ファイル記述子のいずれか早い方です。

--dup-ops N
N bogo オープン操作後に dup ストレス ワーカーを停止します。

--epoll N
を使用して、関連するさまざまなソケット ストレス アクティビティを実行する N 個のワーカーを開始します。
epoll_wait(2) 新しい接続を監視し、処理します。 これにはクライアント/サーバーが関係します
ローカル上で高速接続、送受信、切断を実行するプロセス
ホスト。 epoll を使用すると、多数の接続を効率的に処理できます。
ただし、これにより接続テーブルがいっぱいになり、さらにブロックされる可能性があります。
ソケット接続のため、epoll bogo op 統計に影響します。 IPv4 および IPv6 の場合
ドメインでは、複数のサーバーが複数のポート上に生成されます。 epoll ストレッサーの目的は、
Linuxのみ。

--epoll ドメイン D
使用するドメインを指定します。デフォルトは unix (別名ローカル) です。 現在はipv4、ipv6
および Unix がサポートされています。

--epoll-port P
ソケット ポート P から開始します。N epoll ワーカー プロセスの場合、ポート P ～ (P * 4) - 1 は
ipv4、ipv6 ドメインに使用され、ポート P ～ P-1 は unix ドメインに使用されます。

--epoll-ops N
N bogo 操作後に epoll ワーカーを停止します。

--eventfd N
8 バイトのイベント メッセージを読み書きする N 個の親および子ワーカー プロセスを開始します
それらの間では、eventfd メカニズムを介して通信されます (Linux のみ)。

--eventfd-ops N
N bogo 操作の後に、eventfd ワーカーを停止します。

--exec N
N 個のワーカーを開始し、stress-ng を実行して終了する子を継続的にフォークします。
ほぼすぐに。

--exec-ops N
N ボゴ操作後に幹部ストレスワーカーを停止します。

--exec-max P
tress-ng を実行する P 子プロセスを作成し、それらが終了するのを待ちます。
反復。 デフォルトは 1 だけです。 値を大きくすると、一時的なゾンビが多数作成されます
取得を待っているプロセス。 プロセスが埋まる可能性があります
--exec-max と --exec に高い値を使用した表。

-F N, --fallocate N
N 個のワーカーが継続的にフォールロケート (ファイル領域の事前割り当て) と funcating を開始します。
(ファイルの切り詰め) 一時ファイル。 ファイルが空き容量より大きい場合は、
fallocate は ENOSPC エラーを生成しますが、このエラーはこのストレッサーによって無視されます。

--fallocate-バイト N
割り当てられたファイル サイズ、デフォルトは 1 GB です。 サイズは単位で指定できます。
サフィックス b、k、m、または g を使用したバイト、KBytes、MBytes、および GBytes。

--fallocate-ops N
N bogo fallocate操作後にfallocateストレスワーカーを停止します。

- 故障 N
マイナーおよびメジャー ページ フォールトを生成する N 個のワーカーを開始します。

--fault-ops N
N bogo ページフォールト操作後にページフォールトワーカーを停止します。

--fcntl N
実行する N 個のワーカーを開始します fcntl(2) 各種コマンドで呼び出します。 行使された
コマンド (利用可能な場合) は次のとおりです: 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、および F_SETSIG。

--fcntl-ops N
N 回の fcntl 操作後に fcntl ワーカーを停止します。

--fiemap N
N 個のワーカーを開始し、各ワーカーが多数のランダムに変更されるエクステントを含むファイルを作成します。
ワーカーごとに 4 つの子プロセスが、
FS_IOC_FIEMAP ioctlとします。

--fiemap-ops N
N 個の fimap bogo 操作後に停止します。

--fiemap-size N
フィーマップされたファイルのサイズをバイト単位で指定します。 サイズを単位で指定できます
サフィックス b、k、m、または g を使用したバイト、KBytes、MBytes、および GBytes の値。 より大きなファイル
より多くのエクステントが含まれるため、エクステント情報を収集する際のストレスが増大します。

--fifo N
64 ビット整数を送信することで名前付きパイプを実行する N 個のワーカーを開始します。

--fifo-ops N
N bogo パイプ書き込み操作の後に FIFO ワーカーを停止します。

--fifo-readers N
ワーカーごとに、単純なメソッドを使用して名前付きパイプを読み取る N 個の fifo リーダー ワーカーを作成します。
読み取りをブロックします。

- ファイル名 N
さまざまな長さのファイル名を使用してファイル作成を実行する N 個のワーカーを開始します
許可されるファイル名文字の範囲が含まれます。 これはそれができるかどうかを試します
ファイルシステムで許可されているファイル名の長さを超えており、さまざまなファイル名をテストしました
1 からファイル システムで許可される最大値までの長さ。

--ファイル名-ops N
N bogo ファイル名テスト後にファイル名ワーカーを停止します。

--ファイル名-opts オプト
オプション「opt」に基づいてファイル名に文字を使用します。 有効なオプションは次のとおりです。

オプション 詳細説明
プローブのデフォルト オプション。ファイル システムをプローブして有効な許可文字を探します。
ファイル名に含めてこれらを使用します
posix は、Open Group 基本仕様で指定されている文字を使用します。
第 7 号、POSIX.1-2008、3.278 ポータブル ファイル名の文字セット
ext は、ext2、ext3、ext4 ファイル システムで許可されている文字を使用します。
つまり、NUL と / を除く任意の 8 ビット文字です。

- 群れ N
単一のファイルをロックする N 個のワーカーを開始します。

--群れ-ops N
N ボゴの群れの操作後に群れのストレスを感じる労働者を止めます。

-f N, - フォーク N
start N 個のワーカーが継続的に子をフォークし、すぐに終了します。

--フォークオペレーション N
N bogo 操作後にフォーク ストレス ワーカーを停止します。

--フォークマックス P
P 個の子プロセスを作成し、反復ごとにそれらが終了するのを待ちます。 デフォルト
は 1 だけです。 値を大きくすると、一時的なゾンビ プロセスが多数作成されます。
刈り取られるのを待っています。 高い値を使用すると、プロセス テーブルがいっぱいになる可能性があります。
--fork-max および --fork の値。

--fp-error N
浮動小数点例外を生成する N 個のワーカーを開始します。 計算が実行されます
FE_DIVBYZERO、FE_INEXACT、FE_INVALID、FE_OVERFLOW を強制してチェックします。
FE_UNDERFLOW 例外。 EDOM エラーと ERANGE エラーもチェックされます。

--fp-error-ops N
N 個の bogo 浮動小数点例外の後に停止します。

--fstat N
N 個のワーカーを開始し、ディレクトリ内のファイルを fstat します (デフォルトは / dev).

--fstat-o​​ps N
N bogo fstat 操作後に fstat ストレス ワーカーを停止します。

--fstat-dir ディレクトリにジョブを開始します。
デフォルトの /dev をオーバーライドするには、fstat にディレクトリを指定します。 内のすべてのファイル
ディレクトリは繰り返し fstat されます。

--futex N
futex システム コールを迅速に実行する N 個のワーカーを開始します。 各労働者は XNUMX つを持っています
プロセス、futex ウェイターおよび futex ウェイカー。 ウェイターは非常に小さなものを持って待っています
timeout は、タイムアウトと高速ポーリング futex 待機を強調します。 これはリナックスです
特定のストレスのオプション。

--futex-ops N
N 回の futex 待機操作が成功した後に futex ワーカーを停止します。

- 得る N
すべての get*(2) システム コールを呼び出す N 個のワーカーを開始します。

--get-ops N
N bogo の取得操作後にワーカーの取得を停止します。

--getdent N
ディレクトリを再帰的に読み取る N 個のワーカーを開始します / proc, / dev /, / tmpに, / sys 　 / run
getdents と getdents64 を使用します (Linux のみ)。

--getdent-ops N
N bogo getdent bogo 操作後に getdent ワーカーを停止します。

--getrandom N
/dev/urandom プールから 8192 ランダム バイトを取得する N 個のワーカーを開始します。
ランダムに取得(2) システムコール（Linux のみ）。

--getrandom-ops N
N bogo get 操作の後に getrandom ワーカーを停止します。

- 取り持つ N
を実行する N 個のワーカーを開始します ハンドル名への名前（2）と open_by_handle_at(2)
システムコール。 (Linux のみ)。

--ハンドル操作 N
N 回の処理ボゴ操作後に停止します。

-d N, --hdd N
N 個のワーカーが一時ファイルの書き込み、読み取り、削除を継続的に開始します。

--hdd-バイト N
HDD プロセスごとに N バイトを書き込みます。デフォルトは 1 GB です。 サイズを指定できます
バイト、キロバイト、メガバイト、およびギガバイトの単位で、サフィックス b、k、m、または g を使用します。

--hdd-opts リスト
さまざまなストレス テスト オプションをカンマ区切りのリストとして指定します。 オプションは次のとおりです
以下：

オプション 詳細説明
直接的には、I/O のキャッシュ効果を最小限に抑えようとします。 ファイル I/O 書き込みは、
ユーザー空間バッファーから直接実行され、同期的に実行されます。
転送も試みられます。 同期 I/O を保証するには、次のことも行います。
同期オプションを使用します。
dsync は、出力が基礎となるハードウェアとファイルに確実に転送されるようにします。
メタデータが更新されました (O_DSYNC オープン フラグを使用)。 これは
それぞれに相当する 書きます(2) 続いて次への呼び出しが行われる
fdatasync(2)。 fdatasync オプションも参照してください。
fadv-dontneed は、データが近いうちにアクセスされないことを予期するようにカーネルにアドバイスします。
未来。
fadv-noreuse は、データが XNUMX 回だけアクセスされることを期待するようにカーネルにアドバイスします。
fadv-normal は、データに対する明示的なアクセス パターンが存在しないことをカーネルに通知します。
これはデフォルトのアドバイスの仮定です。
fadv-rnd は、データのランダム アクセス パターンを予期するようにカーネルにアドバイスします。
fadv-seq は、データの順次アクセス パターンを予期するようにカーネルにアドバイスします。
fadv-willneed は、近いうちにデータがアクセスされることを予期するようにカーネルに通知します。
未来。

fsync は、出力に書き込むたびに、変更されたすべてのコア内データをフラッシュします。
明示的を使用するデバイス fsync（2）電話します。
fdatasync は fsync に似ていますが、次の場合を除き、変更されたメタデータをフラッシュしません。
メタデータは、後のデータ読み取りが正しく処理されるために必要です。
これは明示的な fdatasync（2）電話します。
iovec は、読み取り/書き込みではなく、readv/writev 複数のバッファー I/O を使用します。
バッファは 1 回の読み取り/書き込み操作の代わりに、複数の操作に分割されます。
16 バッファーの iovec。
noatime はファイルの最終アクセスのタイムスタンプを更新しません。これにより、タイムスタンプが短縮される可能性があります。
メタデータの書き込み。
sync 出力が基礎となるハードウェアに転送されていることを確認します (使用
O_SYNC オープン フラグ)。 これはそれぞれに相当します 書きます(2) であること
続いて電話 fsync(2)。 fsync オプションも参照してください。
rd-rnd はデータをランダムに読み取ります。 デフォルトでは、書き込まれたデータは読み戻されません。
ただし、このオプションを使用すると、強制的にランダムに読み戻されます。
rd-seq はデータを順番に読み取ります。 デフォルトでは、書き込まれたデータは読み戻されません。
ただし、このオプションを使用すると、強制的に連続して読み取られます。
syncfs は、ファイルのメタデータとデータのバッファリングされた変更をすべて書き込みます。
HDD ワーカー ファイルを含むファイル システム。
utimes はファイルのタイムスタンプを強制的に更新するため、メタデータの書き込みが増加する可能性があります。
wr-rnd はデータをランダムに書き込みます。 wr-seq オプションは同時に使用できません
時間。
wr-seq データをシーケンシャルに書き込みます。 書き込みモードが設定されていない場合、これがデフォルトです。
指定。

これらのオプションの一部は相互に排他的であることに注意してください。たとえば、指定できるのは XNUMX つだけです。
書いたり読んだりする方法。 また、fadvise フラグは相互に排他的になる場合があります。たとえば、
fadv-willneed は fadv-dontneed と一緒に使用できません。

--hdd-ops N
N ボゴ操作後に HDD ストレスワーカーを停止します。

--hdd書き込みサイズ N
各書き込みのサイズをバイト単位で指定します。 サイズは 1 バイトから 4MB までです。

--ヒープソート N
BSD ヒープソートを使用して 32 ビット整数をソートする N 個のワーカーを開始します。

--ヒープソート操作 N
N bogo ヒープソート後にヒープソート ストレス ワーカーを停止します。

--ヒープソートサイズ N
ソートする 32 ビット整数の数を指定します。デフォルトは 262144 (256 × 1024) です。

--hsearch N
次を使用して 80% 完全なハッシュ テーブルを検索する N 個のワーカーを開始します。 検索（3）。 デフォルトでは、
ハッシュ テーブルには 8192 個の要素が挿入されます。 これは便利な方法です
メモリとプロセッサ キャッシュへのアクセスを実行します。

--hsearch-ops N
N bogo hsearch 操作が完了した後で hsearch ワーカーを停止します。

--hsearch-size N
ハッシュ テーブルに挿入するハッシュ エントリの数を指定します。 サイズは
1Kから4Mまで。

--icache N
命令キャッシュを強制することで命令キャッシュにストレスを与える N 個のワーカーを開始します
リロードします。 これは、命令キャッシュ ラインを変更することで実現されます。
内部で関数を呼び出すときにプロセッサを再ロードします。 現在のみ
Intel x86 CPU に対して検証および有効化されています。

--icache-ops N
N bogo icache 操作が完了した後、icache ワーカーを停止します。

--inotify N
作成/削除などのファイル システム アクティビティを実行する N 個のワーカーを開始します
ファイル/ディレクトリ、ファイルの移動など、さまざまな inotify イベントを強調表示します。
（Linuxのみ）。

--inotify-ops N
N inotify bogo 操作後に inotify ストレス ワーカーを停止します。

-i N, --io N
N 人のワーカーが継続的に通話を開始する sync(2) バッファキャッシュをディスクにコミットします。 これ
--hdd オプションと組み合わせて使用​​できます。

--io-ops N
N bogo 操作後に io ストレス ワーカーを停止します。

--itimer N
システム間隔タイマーを実行する N 個のワーカーを開始します。 これにより、
ITIMER_PROF SIGPROF 信号を生成するタイマー。 デフォルトの周波数は、
itimer は 1 MHz ですが、Linux カーネルはこれをそれ以上に設定しません。
設定が簡単であるため、高周波の SIGPROF 信号は通常は可能ではありません。 あ
ビジーループがオンになる 取得タイマー(2) 呼び出しにより CPU が消費されるため、タイマーがデクリメントされます。
CPU とシステム時間に費やされた時間に基づいて計算されます。

--itimer-ops N
N bogo iter の SIGPROF シグナル後に iter ストレス ワーカーを停止します。

--itimer-freq F
F Hz でタイマーを実行します。 範囲は 1 ～ 1000000 Hz です。 通常、最高周波数は
1000 秒あたりのジフィー ティック数によって制限されるため、XNUMX Hz を超える動作は困難です。
実際に達成するのは難しい。

--kcmp N
を使用する N 個のワーカーを開始します kcmp(2) 親プロセスと子プロセスを比較して決定する
カーネル リソースを共有している場合 (Linux のみ)。

--kcmp-ops N
N bogo kcmp 操作後に kcmp ワーカーを停止します。

- 鍵 N
を使用してキーを作成および操作する N 個のワーカーを開始します 追加キー（2）と ケトル（2）。 として
ユーザーごとの制限が許す限り多くのキーが作成され、次の keyctl
コマンドは各キーに対して実行されます: KEYCTL_SET_TIMEOUT、KEYCTL_DESCRIBE、
KEYCTL_UPDATE、KEYCTL_READ、KEYCTL_CLEAR、KEYCTL_INVALIDATE。

--キー操作 N
N bogo キー操作後にキー ワーカーを停止します。

- 殺す N
N 個のワーカーが SIG_IGN シグナル ハンドラーに SIGUSR1 kill シグナルを送信することを開始します。 たいていの
処理時間は最終的にカーネル空間に費やされます。

--kill-ops N
Nボゴ殺害作戦の後に労働者を殺害するのをやめてください。

--klog N
カーネルを実行する N 個のワーカーを開始します syslog(2) システムコール。 これにより、次のことが試みられます
さまざまなサイズの読み取りバッファーを使用してカーネル ログを読み取ります。 Linux のみ。

--klog-ops N
N 個の syslog 操作後に klog ワーカーを停止します。

- リース N
N 人のワーカーが、 fcntl(2) F_SETLEASE
手術。 親プロセスは、ファイルのリースを継続的にロックおよびロック解除します。
ユーザーが選択できる数の子プロセスは、ノンブロッキング オープンでファイルを開きます。
SIGIO リース解除通知を親に生成します。 このストレス要因は、
F_SETLEASE、F_WRLCK、および F_UNLCK サポートが提供されている場合にのみ使用可能 fcntlとします。

--リースオペレーション N
N ボゴ操作後にリース労働者を停止します。

--リースブレーカー N
リース ワーカーごとに N 個のリース ブレーカー子プロセスを開始します。 通常、子供はXNUMX人です
多くの SIGIO リース中断通知信号を親に強制するのに十分です。
ただし、このオプションを使用すると、必要に応じてさらに多くの子プロセスを指定できます。

- リンク N
N 個のワーカーを開始し、ハードリンクを作成および削除します。

--link-ops N
N ボゴ操作後にリンク ストレス ワーカーを停止します。

--ロックバス N
ランダムに選択された 64 バイトのメモリを迅速にロックしてインクリメントする N 個のワーカーを開始します
16MB mmap 領域から (Intel x86 CPU のみ)。 これによりキャッシュラインミスが発生します
そしてCPUのストール。

--lockbus-ops N
N ボゴ操作後にロックバスワーカーを停止します。

--lockf N
POSIX を使用してファイルの領域をランダムにロックおよびロック解除する N 個のワーカーを開始します
ロック(3) ロック機構。 各ワーカーは 64K ファイルを作成し、ファイルを保持しようとします。
子プロセスも 1024 個のロックを保持しようとする、最大 1024 個の同時ロック
同時ロック。 古いロックは先入れ先出し方式でロック解除されます。

--lockf-ops N
N bogo lockf 操作後に lockf ワーカーを停止します。

--lockf-ノンブロック
ブロッキング F_LOCK を使用する代わりに ロック(3) コマンド、ノンブロッキング F_TLOCK を使用
コマンドを実行し、ロックが失敗した場合は再試行してください。 これにより、余分なシステムコールのオーバーヘッドが発生します
lockf ワーカーの数が増加し、増加するはずであるため、CPU 使用率も増加します。
ロック競合。

--longjmp N
N 人の労働者が運動を開始する セットjmp（3）/ロングジャンプ(3) longjmp での高速ループによる
呼び出します。

--longjmp-ops N
N bogo longjmp 操作後に longjmp ストレス ワーカーを停止します (1 bogo op は 1000)
longjmp 呼び出し)。

--lsearch N
を使用して、ソートされていない 32 ビット整数の配列を線形検索する N 個のワーカーを開始します。
調べる(3)。 デフォルトでは、配列には 8192 個の要素があります。 これは便利です
メモリとプロセッサ キャッシュのシーケンシャル アクセスを実行する方法。

--lsearch-ops N
N 回の検索操作が完了したら、検索ワーカーを停止します。

--lsearch-size N
lsearchする配列のサイズ(32ビット整数の数)を指定します。 サイズは
1Kから4Mまで。

--malloc N
N 人のワーカーが継続的に通話を開始する malloc関数（3） 呼び出し（3） 再割り当て（3）と 無料です。とします。
デフォルトでは、いつでも最大 65536 個の割り当てをアクティブにできますが、これは
--malloc-max オプションで変更します。 割り当て、再割り当て、および解放は、
ランダムに選択されます。 時間の 50% はメモリの割り当て (malloc、calloc、または
realloc)、時間割り当ての 50% が解放されます。 割り当てサイズも
ランダム、最大割り当てサイズは --malloc-bytes オプションで制御されます。
デフォルトのサイズは 64K です。 ワーカーが強制終了された場合、ワーカーは再起動されます。
メモリ (OOM) キラー。

--malloc バイト N
割り当て/再割り当てあたりの最大サイズ。 割り当ては 1 つからランダムに選択されます
Nバイトまで。 サイズはバイト、KBytes、MBytes、GBytes の単位で指定できます。
接尾辞 b、k、m、または g を使用します。 割り当てサイズが大きいとメモリ アロケータが発生する
使用する mmap(2) を使用してヒープを拡張するのではなく、 BRKとします。

--malloc-max N
許可されるアクティブな割り当ての最大数。 割り当てはランダムに選択され、
割り当てスロットに配置されます。 なぜなら、割り当てと
解放中、通常、割り当てスロットの半分は常に使用中です。

--malloc-ops N
N malloc bogo 操作の後に停止します。 XNUMX つのボゴ操作が成功に関係します。
malloc関数（3） 呼び出し（3）または 再割り当てとします。

--malloc-スレッシュ N
malloc が使用するしきい値を指定します mmap（2）の代わりに sbrk(2) より多くの割り当てを行う
メモリ。 これは、GNU C を提供するシステムでのみ使用できます。 マロプト(3) チューニング
機能。

- マトリックス N
浮動小数点値に対してさまざまな行列演算を実行する N 個のワーカーを開始します。 による
デフォルトでは、すべてのマトリックス応力法が XNUMX つずつ実行されます。 XNUMX缶
--matrix-method オプションを使用して、特定のマトリックス応力法を指定します。

--マトリックスオペレーション N
N 回のボゴ操作後にマトリックス ストレス ワーカーを停止します。

--マトリックスメソッド 方法
マトリックス応力法を指定します。 利用可能なマトリックス応力法は次のように説明されます。
以下：

方法 詳細説明
すべては、以下のすべてのマトリックス応力メソッドを反復します。
add XNUMX つの N × N 行列を加算する
copy XNUMX つの N × N 行列を別の N × N 行列にコピー
div N × N 行列をスカラーで除算します
hadamard XNUMX つの N × N 行列のアダマール積
フロベニウス XNUMX つの N × N 行列のフロベニウス積
平均 XNUMX つの N × N 行列の算術平均
N × N 行列にスカラーを乗算する
XNUMX つの N × N 行列の prod 積
sub XNUMX つの N × N 行列から別の N × N 行列を減算します。
trans N × N 行列を転置する

--行列サイズ N
行列の N × N サイズを指定します。 値が小さいと浮動小数点になります。
スループット制限ストレッサーを計算します。値が大きいと、キャッシュやキャッシュが発生します。
メモリ帯域幅制限ストレッサー。

--メンバリア N
membarrier システム コールを実行する N 個のワーカーを開始します (Linux のみ)。

-- メンバー操作 N
N ボゴ膜バリア操作後に膜バリアストレスワーカーを停止します。

--memcpy N
を使用して共有領域からバッファに 2MB のデータをコピーする N 個のワーカーを開始します。
memcpy(3) 次に、次のようにしてバッファ内のデータを移動します。 メモリ移動(3) 3 つの異なる
アライメント。 これにより、プロセッサのキャッシュとシステム メモリが使用されます。

--memcpy-ops N
N bogo memcpy 操作後に memcpy ストレス ワーカーを停止します。

--memfd N
次を使用して、256 ページの 1024 の割り当てを作成する N 個のワーカーを開始します。 memfd_create（2）と
切り詰める(2) 割り当ておよび mmap(2) 割り当てをプロセスにマッピングする
アドレス空間。 (Linux のみ)。

--memfd-ops N
Nの後に停止 memfd-作成(2) ボゴ操作。

--マージソート N
BSD マージソートを使用して 32 ビット整数をソートする N 個のワーカーを開始します。

--mergesort-ops N
N bogo マージソート後にマージソート ストレス ワーカーを停止します。

--マージソートサイズ N
ソートする 32 ビット整数の数を指定します。デフォルトは 262144 (256 × 1024) です。

--mincore N
N 個のワーカーを開始し、一度に 1 ページずつメモリ全体を調べて、
ページはマップされており、使用してメモリ内に常駐しています ミンコアとします。

--mincore-ops N
N 分コアのボゴ操作後に停止します。 1000 つのミンコア ボゴ オペレーションは XNUMX に相当します。
ミンコア（2）呼び出し。

--mincore-ランダム
ページを順番に移動するのではなく、ランダムにページを選択します。 選ばれたもの
アドレスは右に XNUMX 桁シフトして反復され、mincore によってチェックされます。
アドレスがページ サイズ以下になるまで。

--mknod N
を使用して、FIFO、空のファイル、および名前付きソケットを作成および削除する N 個のワーカーを開始します。
mknodしてリンクを解除します。

--mknod-ops N
N bogo mknod 操作後にディレクトリ スラッシュ ワーカーを停止します。

--mlock N
を使用してメモリ マップされたページをロックおよびロック解除する N 個のワーカーを開始します ムロック（2）
マンロック（2） ムロックオール（2）と マンロックオール(2)。 これは XNUMX つのマッピングによって実現されます。
連続したページを削除してから XNUMX 番目のページをロックすることで、連続しないことを保証します。
ページはロックされています。 これは、許可される最大 mlock または上限に達するまで繰り返されます。
最大 262144 のマッピングが作成されます。 次に、将来のすべてのマッピングがロックされ、
ワーカーが 262144 ページをマップしようとすると、すべてのページがロックされ、ページがロックされます。
マッピングされていない。

--mlock-ops N
N mlock bogo 操作後に停止します。

--mmap N
N 人のワーカーが継続的に通話を開始する mmap（2）/ムンマップ(2)。 初期マッピングは
大きなチャンク (--mmap-bytes で指定されたサイズ) の後に擬似ランダム 4K
アンマッピング、次に擬似ランダム 4K マッピング、そしてリニア 4K アンマッピング。 注記
これにより、Linux システム上でカーネル OOM キラーが作動する可能性があります。
十分な物理メモリとスワップが利用可能ではありません。 MAP_POPULATE オプションが使用されます
これをサポートするシステム上のメモリにページを挿入します。 デフォルトでは匿名
マッピングが使用されますが、 --mmap-file および --mmap-async オプションを使用すると、
必要に応じて、ファイルベースのマッピングを実行します。

--mmap-ops N
N bogo 操作後に mmap ストレス ワーカーを停止します。

--mmap-async
ファイルベースのメモリマッピングを有効にし、各ページで非同期 msync を使用します。を参照してください。
--mmap ファイル。

--mmap-バイト N
mmap ストレス ワーカーごとに N バイトを割り当てます。デフォルトは 256MB です。 指定できるのは、
サフィックス b、k、m、または g を使用して、バイト、キロバイト、メガバイト、およびギガバイトの単位でサイズを指定します。

--mmap ファイル
ファイルベースのメモリマッピングを有効にし、デフォルトで各メモリで同期msyncを使用します。
ページで見やすくするために変数を解析したりすることができます。

--mmap-mprotect
メモリの各ページの保護設定を変更します。 ページまたはグループごとに、
ページがマップまたは再マップされた場合、このオプションはページを読み取り専用、書き込み専用にします。
のみ、実行専用、および読み取り/書き込み。

--mmapfork N
N 個のワーカーを開始し、それぞれが 32 の子プロセスをフォークし、それぞれが次のことを試みます。
システムに残っている空きメモリの一部を割り当てます（そして、
スワッピング）。 次に、子プロセスは、割り当てが必要であることを次のように示唆します。
マバイス(2) 次に memset をゼロに設定し、次のようにして不要であることを示唆します。
出る前にマッドバイス。 これにより、大量の VM アクティビティが生成されます。
キャッシュミスが発生せず、スワップも最小限に抑えられます。

--mmapfork-ops N
N mmapfork bogo 操作後に停止します。

--mmapmany N
プロセスごとに許可される最大メモリの作成を試みる N 個のワーカーを開始します
マッピング。 これは、3 つの連続したページをマッピングしてから、そのページのマッピングを解除することで実現されます。
中央のページなのでマッピングが XNUMX つに分割されます。 その後、これが完了するまで繰り返されます。
最大許容マッピング数、つまり最大 262144 のマッピングが作成されます。

--mmapmany-ops N
N mmap 回の bogo 操作後に停止します。

--mremap N
N 人のワーカーが継続的に通話を開始する mmap（2） ムリマップ（2）と ムンマップ(2)。 初期
匿名マッピングは大きなチャンク (--mremap-bytes で指定されたサイズ) であり、
ページサイズまで再マッピングすることを繰り返してサイズを半分にします。
元のサイズに戻します。 このワーカーは Linux でのみ使用できます。

--mremap-ops N
N bogo 操作後に mremap ストレス ワーカーを停止します。

--mremap-bytes N
最初はリマップ ストレス ワーカーごとに N バイトを割り当てます。デフォルトは 256MB です。 XNUMX缶
サフィックス b を使用して、バイト、キロバイト、メガバイト、およびギガバイトの単位でサイズを指定します。
k、m、またはg。

--msg N
メッセージを継続的に送受信する N 個の送信側および受信側プロセスを開始します。
System V メッセージ IPC を使用します。

--msg-ops N
N bogo メッセージ送信操作が完了すると停止します。

--mq N メッセージを継続的に送受信する N 個の送信側および受信側プロセスを開始します。
POSIX メッセージ キューを使用します。 (Linux のみ)。

--mq-ops N
N bogo POSIX メッセージ送信操作が完了した後に停止します。

--mq-サイズ N
POSIXメッセージキューのサイズを指定します。 デフォルトのサイズは 10 メッセージで、ほとんどの Linux
システムでは、これが通常のユーザーに許可される最大サイズです。 指定されたサイズが
許可されたメッセージ キュー サイズを超えると、警告が発行され、
代わりに、最大許容サイズが使用されます。

- 良い N
利用可能な Nice レベルを実行する N CPU 消費ワーカーを開始します。 それぞれ
反復により、すべての優れたレベルを実行する子プロセスがフォークされます。
レベルごとに 0.1 秒間ビジー ループを実行してから終了します。

--ナイスオプス N
N回素敵なボゴ素敵なループ後に停止します

- ヌル N
N 個のワーカーが /dev/null への書き込みを開始します。

--null-ops N
N /dev/null bogo 書き込み操作後に null ストレス ワーカーを停止します。

--沼 N
ストレス要因を移行する N 個のワーカーと、すべての周囲の 4MB のメモリ マップド バッファを開始します。
利用可能な NUMA ノード。 これは、 移行ページ(2) ストレス要因を移動させ、
バインド（2）と move_pages(2) マップされたバッファのページを移動します。 それぞれの動きの後に、
バッファはバス上でアクティビティを強制するために書き込まれ、その結果キャッシュミスが発生します。
このテストは、NUMA が有効になっており、複数の NUMA ノードがあるハードウェアでのみ実行されます。

--uma-ops N
N 回の NUMA 操作後に NUMA ストレス ワーカーを停止します。

--oom パイプ N
許可された数のパイプを作成し、拡張と実行を実行する N 個のワーカーを開始します。
パイプを最大のパイプ サイズからページ サイズまで縮小します。 データが書き込まれます
パイプに入力し、再度読み出してパイプ バッファーを満たします。 --aggressive を使用すると
モードが有効な場合、パイプが縮小されるとデータが読み出されず、カーネルが
積極的に OOM プロセスに移行します。 このストレッサーのインスタンスを多数実行すると、強制的に
多くの大きなパイプ バッファ割り当てが原因で、カーネルから OOM プロセスへの影響が大きくなります。

--oom-pipe-ops N
N 個のボゴ パイプ拡張/縮小操作後に停止します。

-o N, - 開いた N
実行する N 個のワーカーを開始します 開いた(2) そしてそれから 閉じる(2) /dev/zero に対する操作。 の
一度に開く最大数はシステムで定義されているため、テストはこの値まで実行されます
最大数、または 65536 個のオープン ファイル記述子のいずれか早い方です。

--open-ops N
N ボゴのオープン操作後にオープン ストレス ワーカーを停止します。

- 人格 N
パーソナリティを設定し、利用可能なすべてのプロパティを取得しようとする N 個のワーカーを開始します
パーソナリティタイプ（プロセス実行ドメインタイプ） 人格(2) システム
電話。 (Linux のみ)。

--パーソナリティ-オペレーション N
N ボゴ人格操作後の人格ストレスワーカーを停止します。

-p N, - パイプ N
大規模なパイプの書き込みと読み取りを実行してパイプ I/O を実行する N 個のワーカーを開始します。
これにより、メモリの書き込みと読み取り、およびコンテキストの切り替えが実行されます。 労働者一人ひとり
には、リーダーとライターという XNUMX つのプロセスがあります。

--パイプ操作 N
N bogo パイプ書き込み操作後にパイプ ストレス ワーカーを停止します。

--パイプデータサイズ N
パイプへの各書き込みのサイズをバイト単位で指定します (範囲は 4 バイトから 4096 バイトまで)
バイト）。 データ サイズを小さく設定すると、より多くの書き込みがバッファリングされます。
パイプを使用するため、パイプライターとパイプ間のコンテキストスイッチ率が減少します。
リーダープロセス。 デフォルトのサイズはページサイズです。

--パイプサイズ N
パイプのサイズをバイト単位で指定します (F_SETPIPE_SZ をサポートするシステムの場合)
fcntl() コマンド)。 パイプ サイズを小さく設定すると、パイプがいっぱいになって詰まります。
より頻繁に実行されるため、パイプライター間のコンテキスト切り替え率が増加します。
そしてパイプリーダープロセス。 デフォルトのサイズは 512 バイトです。

-P N, -世論調査 N
を介してタイムアウトなしのポーリングを実行する N 個のワーカーを開始します。 世論調査（2） select（2）と
眠る(3) 電話をかける。 これにより、何もせずにシステムとユーザーの時間が無駄になります。

--投票操作 N
N bogo 投票操作後に投票ストレス ワーカーを停止します。

--procfs N
ファイルを読み取る N 個のワーカーを開始します / proc からファイルを再帰的に読み取ります
/proc/self （Linuxのみ）。

--procfs-ops N
N bogo 読み取り操作後に procfs 読み取りを停止します。 エントリー数が多いので注意してください
カーネルによって異なる可能性があるため、この bogo ops メトリクスはおそらく非常に誤解を招きます。

--pthread N
複数の pthread を繰り返し作成および終了する N 個のワーカーを開始します (
デフォルトはワーカーあたり 1024 pthread です)。 各反復で、新しく作成された各 pthread
ワーカーがすべての pthread を作成し、その後すべて終了するまで待機します。
一緒に。

--pthread-ops N
N bogo pthread create 操作の後に pthread ワーカーを停止します。

--pthread-max N
ワーカーごとに N 個の pthread を作成します。 pthread の数と
ワーカーの数が許可される pthread のソフト制限を超えている場合、
最大値は、許容される最大値まで再調整されます。

--ptrace N
子プロセスのシステム コールをフォークしてトレースする N 個のワーカーを開始します。
ptraceとします。

--ptrace-ops N
N bogo システムコールがトレースされた後、ptracer ワーカーを停止します。

-NS、 --qsort N
qsort を使用して 32 ビット整数をソートする N 個のワーカーを開始します。

--qsort-ops N
N bogo qsort 後に qsort ストレスワーカーを停止します。

--qsort-size N
ソートする 32 ビット整数の数を指定します。デフォルトは 262144 (256 × 1024) です。

- クォータ N
Q_GETQUOTA、Q_GETFMT、Q_GETINFO、Q_GETSTATS、および
Q_SYNC クォータクトル(2) 使用可能なすべてのマウントされたブロックベースのファイルシステム上のコマンド。

--クォータ操作 N
N bogo quotectl 操作後にクォータ ストレス ワーカーを停止します。

--rdrand N
Intel ハードウェア乱数ジェネレーターを読み取る N 個のワーカーを開始します (Intel
Ivybridge プロセッサ以降)。

--rdrand-ops N
N bogo rdrand 操作後に rdrand ストレス ワーカーを停止します (1 bogo op = 2048 ランダム)
ビットは正常に読み取られました)。

--先読み N
ランダムにシークして 512 バイトの読み取り/書き込み I/O 操作を実行する N 個のワーカーを開始します
先読みのあるファイル上で。 デフォルトのファイル サイズは 1 GB です。 先読みと読み取りは、
16 回の先読みと 16 回の読み取りにバッチ化されます。

--先読みバイト N
先読みファイルのサイズを設定します。デフォルトは 1 GB です。 サイズを指定できるのは、
接尾語 b、k、m、または g を使用したバイト、KBytes、MBytes、GBytes の単位。

--readahead-ops N
N bogo 読み取り操作後に先読みストレス ワーカーを停止します。

--リマップ N
512 ページをマップする N 個のワーカーを開始し、非推奨のメソッドを使用してこれらのページを並べ替えます。
システムコール remap_file_pages(2)。 いくつかのページの並べ替えが実行されます: 前方、
リバース、ランダム、多数のページを 1 ページに。

--remap-ops N
N 回のボゴ操作の再マッピング後に停止します。

-R N, -名前を変更 N
N 個のワーカーを開始し、それぞれがファイルを作成し、その名前を繰り返し変更します。

--名前変更-ops N
N bogo の名前変更操作後にストレス ワーカーの名前変更を停止します。

--rlimit N
CPU とファイル サイズのリソース制限を超える N 個のワーカーを開始し、SIGXCPU を生成します
および SIGXFSZ 信号。

--rlimit-ops N
N bogo リソースが制限された SIGXCPU および SIGXFSZ 信号が捕捉された後に停止します。

--seccomp N
Secure Computing システム コール フィルタリングを実行する N 個のワーカーを開始します。 労働者一人ひとり
/dev/null に短いメッセージを書き込んで終了する子プロセスを作成します。 2%
子プロセスの一部には、書き込みシステム コールを禁止する seccomp フィルターがあります。
したがって、SIGSYS を使用した seccomp によって強制終了されます。 このストレッサーは次のような可能性があることに注意してください。
子が殺害されるたびに、多数の監査ログ メッセージが生成されます。

--seccomp-ops N
N 回の seccomp フィルター テスト後に seccomp ストレス ワーカーを停止します。

- 求める N
ランダムにシークして 512 バイトの読み取り/書き込み I/O 操作を実行する N 個のワーカーを開始します
ファイルに。 デフォルトのファイル サイズは 16 GB です。

--シークオペレーション N
N ボゴシーク操作の後、ストレスワーカーのシークを停止してください。

--シークパンチ
ファイルにランダムに配置された 8K 穴をあけて、より多くのエクステントを強制的に生成します。
要求の高いシーク ストレッサー (Linux のみ)。

--シークサイズ N
ファイルのサイズをバイト単位で指定します。 ファイル サイズが小さいと、I/O が発生します。
キャッシュが減少し、CPU 負荷が増大します。 ファイル サイズが大きいと、より多くの I/O 操作が必要になります
ドライブの待ち時間が長くなり、ドライブ上の I/O が増加します。 サイズを指定できるのは、
接尾語 b、k、m、または g を使用したバイト、KBytes、MBytes、GBytes の単位。

--sem N
POSIX セマフォの待機およびポスト操作を実行する N 個のワーカーを開始します。 デフォルトでは、
ワーカーごとに親と 4 人の子が開始され、
セマフォ。 これにより、高速セマフォ操作が強調され、迅速なコンテキストが生成されます。
切り替え。

--sem-ops N
N bogo セマフォ操作後にセマフォ ストレス ワーカーを停止します。

--sem-procs N
セマフォ上の競合を提供するために、ワーカーごとに N 個の子ワーカーを開始します。
デフォルトは 4 で、最大 64 が許可されます。

--sem-sysv N
System V セマフォの待機およびポスト操作を実行する N 個のワーカーを開始します。 による
デフォルトでは、競合を提供するためにワーカーごとに 4 つの親と XNUMX つの子が開始されます。
セマフォ上で。 これにより、高速セマフォ操作が強調され、高速なセマフォ操作が生成されます。
コンテキストの切り替え。

--sem-sysv-ops N
N bogo System V セマフォ操作後にセマフォ ストレス ワーカーを停止します。

--sem-sysv-procs N
System V セマフォで競合を提供するために、ワーカーごとに N 個の子プロセスを開始します。
デフォルトは 4 で、最大 64 が許可されます。

- ファイルを送信 N
空のファイルを /dev/null に送信する N 個のワーカーを開始します。 この操作にはほぼ次の費用がかかります
常にカーネル内にあります。 デフォルトの送信ファイルのサイズは 4MB です。 送信ファイル
オプションは Linux 専用です。

--sendfile-ops N
N 回の sendfile bogo 操作後に sendfile ワーカーを停止します。

--sendfile-size S
sendfile 呼び出しごとにコピーされるサイズを指定します。 デフォルトのサイズは 4MB です。 XNUMXつ
サフィックスを使用して、バイト、キロバイト、メガバイト、およびギガバイトの単位でサイズを指定できます。
b、k、m、または g。

--shm N
POSIX 共有を使用して共有メモリ オブジェクトを開いて割り当てる N 個のワーカーを開始します
メモリインターフェイス。 デフォルトでは、テストでは 32 の作成と破棄が繰り返し行われます。
共有メモリ オブジェクト。それぞれのサイズは 8MB です。

--shm-ops N
N POSIX 共有メモリの作成および破棄 bogo 操作が完了した後に停止します。

--shm バイト N
作成する POSIX 共有メモリ オブジェクトのサイズを指定します。 指定できます
サフィックス b、k、m または
g.

--shm-objs N
作成する共有メモリ オブジェクトの数を指定します。

--shm-sysv N
System V 共有メモリを使用して共有メモリを割り当てる N 個のワーカーを開始します
インターフェース。 デフォルトでは、テストでは 8 つの共有メモリの作成と破棄が繰り返し行われます。
各セグメントのサイズは 8MB です。

--shm-sysv-ops N
N 個の共有メモリの作成および破棄の bogo 操作が完了した後に停止します。

--shm-sysv-バイト N
作成する共有メモリセグメントのサイズを指定します。 指定できるのは、
サフィックス b、k、m、または g を使用して、バイト、キロバイト、メガバイト、およびギガバイトの単位でサイズを指定します。

--shm-sysv-segs N
作成する共有メモリセグメントの数を指定します。

--sigfd N
SIGRT シグナルを生成し、子による読み取りによって処理される N 個のワーカーを開始します
を使用して設定されたファイル記述子を使用して処理する 信号FD(2)。 (Linux のみ)。 この意志
すべての CPU が完全にロードされると、コンテキスト スイッチの大きな負荷が発生します。

--sigfd-ops
N bogo SIGUSR1 シグナルが送信された後に sigfd ワーカーを停止します。

--sigfpe N
ゼロ除算 SIGFPE フォールトを急速に引き起こす N 個のワーカーを開始します。

--sigfpe-ops N
N bogo SIGFPE エラーの後に sigfpe ストレス ワーカーを停止します。

-- 署名待ち N
SIGUSR1 シグナルが保留中かどうかを確認する N 個のワーカーを開始します。 このストレッサーマスク
SIGUSR1、SIGUSR1 信号を生成し、 署名待ち(2) 信号が届いているかどうかを確認します。
保留中。 次に、シグナルのマスクを解除し、シグナルが保留中でなくなったかどうかを確認します。

--signpending-ops N
N bogo sigpending pending/unpending check の後で、sigpending ストレス ワーカーを停止します。

--sigsegv N
セグメンテーション フォールトを迅速に作成して捕捉する N 個のワーカーを開始します。

--sigsegv-ops N
N bogo セグメンテーション違反後に sigsegv ストレス ワーカーを停止します。

--sigsuspend N
N 個のワーカーを開始し、それぞれが SIGUSR4 を待機する 1 つの子プロセスを生成します。
を使用して親からの信号 シグサスペンド(2)。 親は SIGUSR1 シグナルを送信します。
それぞれの子供たちが次々と。 各 sigsuspend ウェイクアップは XNUMX ボゴとしてカウントされます
操作。

--sigsuspend-ops N
N bogo sigsuspend ウェイクアップ後に stop sigsuspend ストレス ワーカーを実行します。

--sigq N
を使用して SIGUSR1 シグナルを迅速に送信する N 個のワーカーを開始します。 シグキュー(3)子供へ
シグナルを待つプロセス シグウェイト情報とします。

--sigq-ops N
N bogo シグナル送信操作後に sigq ストレス ワーカーを停止します。

- 寝る N
それぞれが複数のスリープを実行する複数のスレッドを生成する N 個のワーカーを開始します
範囲は 1us ～ 0.1s です。 これにより、複数のコンテキスト スイッチとタイマーが作成されます
割り込み。

--スリープ作戦 N
N 回のスリープ ボゴ操作後に停止します。

--スリープマックス P
ワーカーごとに P 個のスレッドを開始します。 デフォルトは 1024 で、許可される最大値は 30000 です。

-S N, - 靴下 N
さまざまなソケット ストレス アクティビティを実行する N 個のワーカーを開始します。 これにはペアが関係します
高速接続、送受信を実行するクライアント/サーバー プロセスの数
ローカルホスト上で切断されます。

--sock-ドメイン D
使用するドメインを指定します。デフォルトは ipv4 です。 現在、ipv4、ipv6、unix は
。

--靴下-遅延なし
これにより、TCP Nagle アルゴリズムが無効になるため、データ セグメントは常にすぐに送信されます。
可能。 これにより、データが送信される前にバッファリングされることがなくなります。
その結果、ネットワークの使用率が低下し、コンテキストの切り替えが多くなります。
送り手と受け手。

--ソックポート P
ソケット ポート P から開始します。N ソケット ワーカー プロセスの場合、ポート P ～ P - 1 が使用されます。

--靴下 N
N bogo 操作後にソケット ストレス ワーカーを停止します。

--sock-opts [ 送信 | メッセージを送る | mmsgを送信 ]
デフォルトでは、メッセージは次を使用して送信されます。 送信(2)。 このオプションを使用すると、
を使用した送信方法 送信（2） メッセージを送る（2）または mmsgを送信(2)。 sendmmsg は
このシステム コールをサポートする Linux システムでのみ使用できます。

--sockfd N
を使用して UNIX ドメイン ソケット経由でファイル記述子を渡す N 個のワーカーを開始します。
CMSG(3) 補助データメカニズム。 ワーカーごとに、クライアント/サーバー プロセスのペア
が作成されると、サーバーは /dev/null 上でできるだけ多くのファイル記述子を開き、
これらをソケット経由でクライアントに渡し、クライアントはこれらを CMSG データから読み取ります。
すぐにファイルを閉じます。

--sockfd-ops N
N bogo 操作後に sockfd ストレス ワーカーを停止します。

--靴下ペア N
ソケット ペア I/O 読み取り/書き込みを実行する N 個のワーカーを開始します。 これには次のペアが含まれます。
ランダムなサイズのソケット I/O 操作を実行するクライアント/サーバー プロセス。

--sockpair-ops N
N bogo 操作後にソケット ペアのストレス ワーカーを停止します。

--スポーン N
N 個のワーカーを開始して、子を継続的に生成します。 posix_spawn(3) ストレスngを実行する
そしてほぼすぐに終了します。

--spawn-ops N
N bogo がスポーンした後にストレスワーカーのスポーンを停止します。

- スプライス N
データを /dev/zero から /dev/null にパイプ経由でコピーせずに移動します。
カーネルアドレス空間とユーザーアドレス空間を使用する スプライス(2)。 これのみが利用可能です
Linuxの場合

--splice-ops N
N 回のボゴ スプライス操作後に停止します。

--スプライスバイト N
スプライス呼び出しごとに N バイトを転送します。デフォルトは 64K です。 サイズを指定できるのは、
接尾語 b、k、m、または g を使用したバイト、KBytes、MBytes、GBytes の単位。

- スタック N
を使用して、スタック オーバーフローを迅速に発生させてキャッチする N 個のワーカーを開始します。 アロカとします。

--スタックフル
デフォルトのアクションは、各スタック割り当ての最下位ページをタッチすることです。 これ
このオプションは、新しいスタック割り当てをゼロで埋めることによってすべてのページにアクセスします。
物理ページの割り当てを強制するため、より積極的です。

--スタックオペレーション N
N bogo スタック オーバーフロー後にスタック ストレス ワーカーを停止します。

--str N
ランダムな文字列に対してさまざまな libc 文字列関数を実行する N 個のワーカーを開始します。

--str メソッド ストラファンク
強調する特定の libc 文字列関数を選択します。 利用可能な文字列関数
ストレスは、all、index、rindex、strcasecmp、strcat、strchr、strcoll、strcmp、
strcpy、strlen、strncasecmp、strncat、strncmp、strrchr、および strxfrm。 見る string(3)
これらの文字列関数の詳細については、「」を参照してください。 「all」メソッドがデフォルトです
すべての文字列メソッドを実行します。

--str-ops N
N 回のボゴ文字列操作後に停止します。

- ストリーム N
STREAM に基づいて大まかにメモリ帯域幅ストレッサーを実行する N 個のワーカーを開始します
「高性能コンピュータの持続可能なメモリ帯域幅」ベンチマーク ツール
ジョン D. マカルピン博士このストレッサーは少なくとも 4 倍のバッファを割り当てます。
CPU L2 キャッシュのサイズを決定し、次のラウンドを継続的に実行します。
倍精度浮動小数点数の大きな配列の計算:

操作 詳細説明
コピー c[i] = a[i]
スケール b[i] = スカラー * c[i]
c[i] = a[i] + b[i] を追加します。
トライアド a[i] = b[i] + (c[i] * スカラー)

これは大まかに STREAM ベンチマーク コードの変種に基づいているため、行わないでください。
これはストレスを強調するためだけに意図されているため、これに基づいて結果を送信します
メモリとコンピューティングであり、STREAM 向けではありません。正確に調整または調整されていない
何でもベンチマーク。 必要に応じて、公式の STREAM ベンチマーク ツールを使用してください
正確で標準化された STREAM ベンチマーク。

--ストリーム操作 N
N ストリームのボゴ操作の後に停止します。ここで、ボゴ操作は XNUMX ラウンドのコピーです。
スケール、追加、トライアド操作。

--stream-l3-size N
CPU レベル 3 キャッシュ サイズをバイト単位で指定します。 サイズは単位で指定できます。
サフィックス b、k、m、または g を使用したバイト、KBytes、MBytes、および GBytes。 L3キャッシュの場合
サイズが指定されていない場合、stress-ng はキャッシュ サイズを決定しようとします。
これに失敗すると、サイズはデフォルトで 4MB になります。

-s N, - スイッチ N
コンテキストの切り替えを強制するためにパイプ経由で子にメッセージを送信する N 個のワーカーを開始します。

--switch-ops N
N 回の bogo 操作後にコンテキスト切り替えワーカーを停止します。

-シンボリックリンク N
N 個のワーカーを開始し、シンボリック リンクを作成および削除します。

--symlink-ops N
N bogo 操作後にシンボリックリンク ストレス ワーカーを停止します。

--同期ファイル N
ファイル全体でさまざまなデータ同期を実行する N 個のワーカーを開始します。
同期ファイル範囲(2)。 同期の XNUMX つのミックスが開始から終了まで実行されます。
ファイルの末尾から先頭まで、およびランダムなミックス。 ランダムな選択
有効な同期タイプが使用され、SYNC_FILE_RANGE_WAIT_BEFORE をカバーします。
SYNC_FILE_RANGE_WRITE および SYNC_FILE_RANGE_WAIT_AFTER フラグ ビット。

--sync-file-ops N
N 回の bogo 同期操作後に同期ファイル ワーカーを停止します。

--同期ファイルバイト N
同期するファイルのサイズを指定します。 サイズは単位で指定できます。
サフィックス b、k、m、または g を使用したバイト、KBytes、MBytes、および GBytes。

--sysinfo N
継続的にシステムを読み取り、特定の情報を処理する N 個のワーカーを開始します。
これにより、プロセスのユーザー時間とシステム時間が読み取られます。 回数(2) システムコール。 のために
Linux システムでは、システム全体の統計も読み取ります。 SYSINFO(2) システム
呼び出しと、マウントされたすべてのファイル システムのファイル システム統計も使用します。
ステータスとします。

--sysinfo-ops N
N 回の bogo 操作後に sysinfo ワーカーを停止します。

--sysfs N
ファイルを再帰的に読み取る N 個のワーカーを開始します / sys (Linux のみ)。 これにより発生する可能性があります
特定のカーネル ドライバーがメッセージをカーネル ログに出力します。

--sys-ops N
N bogo 読み取り操作後に sysfs 読み取りを停止します。 エントリー数が多いので注意してください
カーネルによって異なる可能性があるため、この bogo ops メトリクスはおそらく非常に誤解を招きます。

--ティー N
書き込みプロセスからパイプを介して読み取りプロセスにデータを移動し、/dev/null にデータを移動します。
カーネルアドレス空間とユーザーアドレス空間の間でコピーを行わずに、
tee(2)。 これは Linux でのみ使用できます。

--ティーオプ N
N ボゴティー操作後に停止します。

-T N, - タイマー N
N 個のワーカーを開始し、デフォルトのレート 1 MHz でタイマー イベントを作成します (Linux のみ)。 これ
何千ものタイマー クロック割り込みを作成することができます。 各タイマーイベントが捕捉される
シグナル ハンドラーによってボゴ タイマー オペレーションとしてカウントされます。

--タイマー操作 N
N bogo タイマー イベント後にタイマー ストレス ワーカーを停止します (Linux のみ)。

--タイマー頻度 F
タイマーを F Hz で実行します。 範囲は 1 ～ 1000000000 Hz (Linux のみ)。 を選択することで、
適切な周波数のストレスにより、数十万の割り込みが生成される可能性があります
毎秒。

--タイマーランド
タイマー周波数 +/- 12.5% のランダム ジッターを中心にタイマー周波数を選択します。
これは、スケジュールを作成するためにタイマー間隔の変動を強制しようとします。
予測可能性が低くなります。

--timerfd N
デフォルトのレート 1 MHz で timerfd イベントを作成する N 個のワーカーを開始します (Linux のみ)。
これにより、何千ものタイマー クロック イベントが作成される可能性があります。 タイマーイベントが待機されています
タイマー ファイル記述子で使用する select(2) その後、読み取ってボゴとしてカウントします
タイマーFDOP.

--timerfd-ops N
N bogo timerfd イベント後に timerfd ストレス ワーカーを停止します (Linux のみ)。

--timerfd-freq F
タイマーを F Hz で実行します。 範囲は 1 ～ 1000000000 Hz (Linux のみ)。 を選択することで、
適切な周波数のストレスにより、数十万の割り込みが生成される可能性があります
毎秒。

--timerfd-rand
タイマー周波数 +/- 12.5% ランダムに基づいてタイマー周波数を選択します
ジッター。 これは、タイマー間隔の変動を強制して、
スケジュールが予測しにくい。

--tsc N
ループ反復ごとにタイム スタンプ カウンター (TSC) を 256 回読み取る N 個のワーカーを開始します
（ボゴ操作）。 Intel x86 プラットフォームでのみ利用可能です。

--tsc-ops N
N 個の bogo 操作が完了した後に tsc ワーカーを停止します。

--tsearch N
バイナリ ツリー上で 32 ビット整数を挿入、検索、削除する N 個のワーカーを開始します
検索（3） 見つける（3）と t削除(3)。 デフォルトでは、65536 個がランダム化されています。
ツリーで使用される整数。 これは、ランダムアクセスを実行するのに便利な方法です。
メモリとプロセッサのキャッシュ。

--tsearch-ops N
N 個の bogo ツリー操作が完了した後、tsearch ワーカーを停止します。

--tsearch-size N
tsearchに配列のサイズ(32ビット整数の数)を指定します。 サイズは
1Kから4Mまで。

--udp N
UDP を使用してデータを送信する N 個のワーカーを開始します。 これにはクライアント/サーバーのペアが必要です
ローカル上で高速接続、送受信、切断を実行するプロセス
ホスト。

--udp ドメイン D
使用するドメインを指定します。デフォルトは ipv4 です。 現在、ipv4、ipv6、unix は
。

--udp-lite
UDP-Lite (RFC 3828) プロトコルを使用します (ipv4 および ipv4 ドメインのみ)。

--udp-ops N
N bogo 操作後に udp ストレス ワーカーを停止します。

--udp ポート P
N udp ワーカー プロセスの場合、ポート P ～ P - 1 が使用されます。 デフォルトでは、
ポート 7000 以降が使用されます。

--udp-フラッド N
ランダムなポートへの UDP パケットでホストをフラッディングしようとする N 個のワーカーを開始します。
現在、パケットの IP アドレスはスプーフィングされていません。 これは以下でのみ利用可能です
AF_PACKET をサポートするシステム。

--udp-フラッドドメイン D
使用するドメインを指定します。デフォルトは ipv4 です。 現在、ipv4 と ipv6 は
。

--udp-フラッドオプス N
N bogo 操作後に udp-flood ストレス ワーカーを停止します。

--共有解除 N
それぞれが 32 の子プロセスをフォークする N 個のワーカーを開始し、それぞれが
unshare(2) プロセス実行コンテキストの一部を切り離してシステムコールを行う。
（Linuxのみ）。

--unshare-ops N
N 回の bogo 共有解除操作後に停止します。

-u N, --ランダム N
/dev/urandom を読み取る N 個のワーカーを開始します (Linux のみ)。 これによりカーネルがランダムにロードされます
数字のソース。

--urandom-ops N
N urandom bogo 読み取り操作後に urandom ストレス ワーカーを停止します (Linux のみ)。

--userfaultfd N
匿名でマップされた小規模な書き込みページ フォールトを生成する N 個のワーカーを開始します。
メモリ領域を管理し、ユーザー空間の障害処理を使用してこれらの障害を処理します。
userfaultfd メカニズム。 これにより、大量のメジャー ページ フォールトが生成され、
また、ページフォールトの処理中にコンテキストが切り替わります。 (Linux のみ)。

--userfaultfd-ops N
N ページフォールト後に userfaultfd ストレスワーカーを停止します。

--userfaultfd-bytes N
ページフォールトに mmap する userfaultfd ワーカーごとに N バイト、デフォルトは 16MB です。
サフィックス b を使用して、バイト、キロバイト、メガバイト、およびギガバイトの単位でサイズを指定します。
k、m、またはg。

--utime N
ファイルのタイムスタンプを更新する N 個のワーカーを開始します。 デフォルトの場合、これは主に CPU バウンドです。
システムがメタデータの変更を定期的にのみフラッシュするために使用されます。

--utime-ops N
N utime bogo 操作後に utime ストレスワーカーを停止します。

--utime-fsync
ファイルのタイムスタンプが更新されるたびに、メタデータの変更がディスクにフラッシュされるように強制します。 これ
テストが強制的に I/O バウンドになり、多くのダーティなメタデータの書き込みが発生します。

--vecmath N
さまざまなデータに対してさまざまな符号なし整数演算を実行する N 個のワーカーを開始します。
128 ビット ベクトル。 ベクトル演算演算の組み合わせが以下に対して実行されます。
ベクトル: 16 × 8 ビット、8 × 16 ビット、4 × 32 ビット、2 × 64 ビット。 生成されるメトリクス
この組み合わせは、プロセッサ アーキテクチャとベクトル演算の最適化に依存します。
コンパイラによって生成されます。

--vecmath-ops N
N 個のボゴ ベクトル整数演算後に停止します。

--vfork N
N 個のワーカーが継続的に子を vfork し、すぐに終了します。

--vfork-ops N
N bogo 操作後に vfork ストレス ワーカーを停止します。

--vfork-max P
P 個のプロセスを作成し、反復ごとにそれらが終了するのを待ちます。 デフォルトは
ちょうど 1; 値を大きくすると、待機中の一時的なゾンビ プロセスが多数作成されます。
刈り取られること。 高い値を使用するとプロセス テーブルがいっぱいになる可能性があります
--vfork-max および --vfork の場合。

-m N, --vm N
N 人のワーカーが継続的に通話を開始する mmap（2）/ムンマップ(2) 割り当てられた領域への書き込み
メモリ。 これにより、システムが Linux 上のカーネル OOM キラーを作動させる可能性があることに注意してください。
システムに十分な物理メモリがなく、スワップが利用できない場合。

--vm バイト N
mmap は VM ワーカーごとに N バイト、デフォルトは 256MB です。 サイズを単位で指定できます
サフィックス b、k、m、または g を使用したバイト、KBytes、MBytes、および GBytes の値。

--vm-ストライド N
バージョン0.03.02以降非推奨

--vm-ops N
N bogo 操作後に VM ワーカーを停止します。

--vm-ハング N
メモリのマッピングを解除する N 秒前にスリープします。デフォルトは 0 秒です。 XNUMXを指定する
無限待機を行います。

--vm-キープ
メモリのマッピング解除とマッピングを継続的に行うのではなく、メモリへの再書き込みを続けてください。

--vm-locked
mmap MAP_LOCKED を使用して、マップされた領域のページをメモリにロックします (Linux 以降)
2.5.37)。 これは、で説明されているメモリのロックに似ています。 ムロックとします。

--vm-メソッド m
vm ストレス法を指定します。 デフォルトでは、すべてのストレスメソッドが実行されます。
ただし、必要に応じて、使用するメソッドを XNUMX つだけ指定することもできます。 それぞれ
の VM ワーカーには 3 つのフェーズがあります。

1.初期化済み。 匿名メモリ マップ領域は既知のパターンに設定されます。

2. 運動した。 記憶は既知の予測可能な方法で変更されます。 一部の VM ワーカーが変更する
記憶を順番に記憶していく場合もあれば、記憶に沿って歩幅を小さくしたり大きくしたりする人もいます。

3. チェック済み。 変更されたメモリが期待されたものと一致するかどうかがチェックされます。
結果。

名前に「prime」を含む vm メソッドは、最大の素数のストライドを持ちます。
2^64 未満なので、メモリを徹底的に調べてすべてに触れることができます。
それぞれの隣のメモリセルに触れることなく、位置を一度だけ実行します
他の。 この戦略は、キャッシュとページの非局所性を利用します。

実行されているメモリは仮想的にマッピングされているため、次のことが保証されません。
ページアドレスを特定の物理的順序でタッチすること。 これらの労働者は、
すべてのシステムのメモリが正しく動作しているかどうかをテストするために使用するか、ツールを使用します。
代わりに memtest86 などを使用します。

vm ストレス法は、次のような方法で記憶力を行使することを目的としています。
メモリの問題や、熱エラーを強制的に試みる可能性があります。

利用可能な VM ストレス方法は次のとおりです。

方法 詳細説明
すべては、以下にリストされているすべての vm ストレス メソッドを反復します。
順番に反転してメモリを 8 回処理します。毎回、
メモリ内の XNUMX ビットが反転 (反転) されました。 これにより、効果的に
8 パスで各バイトを反転します。
galpat-0 ギャロッピング パターン ゼロ。 これにより、すべてのビットが 0 に設定され、反転されます。
1 ビットの 4096 を 1 に変換します。次に、1 が XNUMX であるかどうかを確認します。
隣接するものまたは他のものによって 0 にプルダウンされます。
隣人は 1 に引き上げられました。
galpat-1 ギャロッピングパターンのもの。 これにより、すべてのビットが 1 に設定され、反転されます。
1 ビットの 4096 を 0 に変換します。次に、0 が XNUMX であるかどうかを確認します。
隣人または隣人によって 1 に引き上げられます
0まで引き下げられました。
グレー 連続したグレー コードでメモリを埋めます (これらのみ)
隣接するバイト間で一度に 1 ビットを変更します)、その後
正しく設定されているかどうかを確認してください。
incdec はメモリを XNUMX 回順に処理し、最初のパスで
各バイトを特定の値ずつ増分し、XNUMX 番目の値を増分します。
pass は、各バイトをデクリメントして元の開始値に戻します。
増分/減分値は、呼び出しのたびに変化します。
ストレス要因。
inc-nybble はメモリを設定値に初期化します (設定値は毎回変更されます)。
ストレッサーの呼び出し）、その後順次動作します
各バイトを通じて下位 4 ビットを 1 ずつインクリメントし、
上位 4 ビットを 15 倍にします。
rand-set は 64 ビット チャンク設定でメモリを順次処理します
チャンク内のバイトを同じ 8 ビットのランダム値に変換します。 の
ランダムな値はチャンクごとに変化します。 値を確認してください
変わっていない。
rand-sum はすべてのメモリをランダムな値に順次設定し、
から変更されたビット数を合計します。
元の設定値。
read64 ボゴごとに 32 x 64 ビット読み取りを使用してメモリを順次読み取ります
ループ。 各ループは XNUMX つの bogo 操作に相当します。 これ
生のメモリ読み取りを実行します。
r ランダムなパターンでメモリを埋めてから、順番にメモリを埋める
64 ビットのメモリを XNUMX ビット右に回転させてから、
最終的な値のロード/回転/保存。
64 バイトのチャンク内のメモリをランダムなパターンでスワップフィルします。 それから
64 個の各チャンクをランダムに選択されたチャンクと交換します。 ついに、
スワップを元に戻してチャンクを元に戻します
を配置し、データが正しいかどうかを確認します。 この演習は
隣接メモリとランダムメモリのロード/ストア。
move-inv は、一度に 64 ビットのメモリを順番に埋めていきます。
ランダムな値を取得し、メモリが設定されているかどうかを確認します
正しく。 次に、各 64 ビット パターンを順番に反転します。
メモリが期待どおりに設定されているかどうかを再度確認します。

modulo-x は 23 回の反復にわたってメモリを埋めます。 各反復は XNUMX つずつ開始します
メモリとステップの先頭からさらに進んだバイト
23 バイトのストライドで進みます。 各ストライドの最初のバイトは次のとおりです。
ランダムなパターンに設定され、他のすべてのバイトは
逆。 次に、最初のバイトに
予想されるランダムパターン。 これはキャッシュの保存/読み取りを実行します。
隣接するセルが各セルに影響を与えるかどうかを確認するだけでなく、
その他。
prime-0 は非常に大きなメモリをステップスルーして 8 回反復します
プライムストライドは、各バイトで一度にビットだけをクリアします。
次に、すべてのビットがゼロに設定されているかどうかを確認します。
prime-1 は非常に大きなメモリをステップスルーして 8 回反復します
プライムストライドは、各バイトで一度にビット単位で設定されます。
次に、すべてのビットが XNUMX に設定されているかどうかを確認します。
prime-gray-0 非常に大きな素数ストライドでメモリを通過する最初のステップ
すべてのバイトのビットのみ (グレー コードに基づいて) をクリアします。
次に、これを繰り返しますが、他の 7 ビットをクリアします。 次に、チェックしてください
すべてのビットがゼロに設定されているかどうかを確認します。
prime-gray-1 非常に大きな素数ストライドでメモリを通過する最初のステップ
すべてのバイトのビット (グレー コードに基づいて) のみを設定します。
次に、これを繰り返しますが、他の 7 ビットを設定します。 次に、チェックしてください
すべてのビットが XNUMX に設定されているかどうかを確認します。
Rowhammer は Rowhammer メモリを使用して強制的にメモリ破損を試みます
ストレス要因。 これはメモリから 32 つの XNUMX ビット整数をフェッチし、
XNUMX つのアドレスのキャッシュ フラッシュを複数回強制します。
これにより、一部のハードウェアでビット フリッピングが強制されることが知られています。
特にメモリリフレッシュサイクルの頻度が低い場合。
メモリ内の各バイトに対して walk-0d、各データ ラインをウォークスルーします
それらを低く設定し（他のものは高く設定）、チェックしてください
書き込まれた値が期待どおりであることを確認します。 これにより、存在するかどうかがチェックされます
データラインが詰まっています。
メモリ内の各バイトに対して walk-1d、各データ ラインをウォークスルーします
それらを高に設定し（他のものは低に設定）、チェックしてください
書き込まれた値が期待どおりであることを確認します。 これにより、存在するかどうかがチェックされます
データラインが詰まっています。
指定されたメモリ マッピングで walk-0a を実行し、範囲の範囲を処理します。
特別に選択されたアドレスがアドレス行を通じて機能し、
アドレス行が Low のままになっているかどうかを確認します。 これが一番うまくいきます
ただし、物理メモリのアドレス指定を使用してこれらを実行すると、
仮想アドレスにもある程度の価値があります。
指定されたメモリ マッピングで walk-1a を実行し、範囲の範囲を処理します。
特別に選択されたアドレスがアドレス行を通じて機能し、
アドレス行がハイレベルでスタックしていないかどうかを確認してください。 これが一番うまくいきます
ただし、物理メモリのアドレス指定を使用してこれらを実行すると、
仮想アドレスにもある程度の価値があります。
write64 ボゴごとに 32 x 64 ビット書き込みを使用してメモリに順次書き込みます
ループ。 各ループは XNUMX つの bogo 操作に相当します。 これ
生のメモリへの書き込みを実行します。 メモリへの書き込みは次のとおりであることに注意してください。
各テスト反復の最後にはチェックされません。
ゼロ-XNUMX すべてのメモリビットをゼロに設定し、ビットがゼロであるかどうかを確認します。
ゼロではありません。 次に、すべてのメモリビットを XNUMX に設定し、
どのビットも XNUMX ではありません。

--vm-populate
メモリ マッピング用に (デフォルトの) ページ テーブルを設定します。 これにより、スワップにストレスがかかる可能性があります。
MAP_POPULATE をサポートするシステムでのみ使用できます (Linux 2.5.46 以降)。

--vm-rw N
を使用して親/子との間でメモリを転送する N 個のワーカーを開始します。
process_vm_writev（2）と process_vm_readv(2)。 この機能は以下でのみサポートされています
リナックス。 メモリ転送は、--verify オプションが有効な場合にのみ検証されます。

--vm-rw-ops N
N メモリの読み取り/書き込み後に vm-rw ワーカーを停止します。

--vm-rw-バイト N
mmap vm-rw ワーカーごとに N バイト、デフォルトは 16MB です。 サイズを指定できるのは、
接尾語 b、k、m、または g を使用したバイト、KBytes、MBytes、GBytes の単位。

--vm-スプライス N
データをメモリから /dev/null にパイプ経由でコピーせずに移動します。
カーネルアドレス空間とユーザーアドレス空間を使用する vmsplice（2）と スプライス（2）。 この
Linux でのみ利用可能です。

--vm-splice-ops N
N bogo vm-splice 操作後に停止します。

--vm-スプライスバイト N
vmsplice 呼び出しごとに N バイトを転送します。デフォルトは 64K です。 サイズを指定できるのは、
接尾語 b、k、m、または g を使用したバイト、KBytes、MBytes、GBytes の単位。

- 待つ N
XNUMX つの子を生成する N 個のワーカーを開始します。 XNUMXつが回転します 一時停止(2) ループ、
もう一方は継続的に停止し、最初のものを継続します。 制御プロセスは待機します
を使用して SIGCONT の配信によって再開される最初の子 待ってください（2）と
待機中とします。

--待機操作 N
N 回の bogo 待機操作後に停止します。

--トイレ N
さまざまな libc ワイド文字列関数を実行する N 個のワーカーを開始します。
ランダムな文字列。

--wcs-メソッド wcsfunc
強調する特定の libc ワイド文字列関数を選択します。 利用可能な文字列
強調する関数は、all、wcscasecmp、wcscat、wcschr、wcscoll、wcscmp、wcscpy、
wcslen、wcsncasecmp、wcsncat、wcsncmp、wcsrchr、および wcsxfrm。 「すべて」メソッドは
デフォルトで、すべての文字列メソッドが実行されます。

--wcs-ops N
N bogo ワイド文字列操作後に停止します。

--xattr N
拡張属性のバッチを作成、更新、削除する N 個のワーカーを開始します。
ファイルにソフトウェアを指定する必要があります。

--xattr-ops N
N bogo 拡張属性操作後に停止します。

-y N, - 収率 N
呼び出す N 個のワーカーを開始する sched_yield(2)。 このストレッサーにより、少なくとも 2
CPU 実行ごとの子プロセス数 盾の利回り(2) 従業員の数に関係なく
これにより、常に迅速なコンテキスト切り替えが保証されます。

--yield-ops N
N の後に降伏応力ワーカーを停止する sched_yield(2) ボゴ操作。

- 零 N
/dev/zero を読み取る N 個のワーカーを開始します。

--ゼロオペレーション N
N /dev/zero bogo 読み取り操作後にゼロ ストレス ワーカーを停止します。

--zlib N
N 個のワーカーが zlib を使用してランダム データを圧縮および解凍することを開始します。 労働者一人ひとり
XNUMX つのプロセスがあり、XNUMX つはランダム データを圧縮し、それを別のプロセスにパイプします。
データを解凍します。 このストレス要因により、CPU、キャッシュ、メモリが使用されます。

--zlib-ops N
N 個の bogo 圧縮操作後に停止します。各 bogo 圧縮操作は
最高の圧縮レベルで 64K のランダム データを圧縮します。

- ゾンビ N
ゾンビプロセスを作成する N 個のワーカーを開始します。 これにより、急速に
デフォルトの 8192 個の子プロセスはすぐに終了し、ゾンビ状態で待機します。
刈り取られるまで。 プロセスの最大数に達すると (またはフォークすると、
許可される子の最大数に達したため失敗します) 最も古いもの
子が取得され、新しいプロセスが先入れ先出し方式で作成されます。
そしてそれを繰り返しました。

--ゾンビ作戦 N
Nボゴゾンビ作戦後にゾンビストレスワーカーを止めます。

--ゾンビマックス N
N 個のゾンビ プロセスを作成してみてください。 システムが次の場合にはこの値に達しない可能性があります。
制限は N 未満です。

例

ストレス-ng --cpu 4 --io 2 --vm 1 --vm-bytes 1G --timeout 60s

を使用して、60 つの CPU ストレッサー、4 つの IO ストレッサー、および 2 つの VM ストレッサーで 1 秒間実行します。
1GBの仮想メモリ。

ストレス-ng --cpu 8 --cpu-ops 800000

8 つの CPU ストレッサーを実行し、800000 回の bogo 操作後に停止します。

ストレス-ng --sequential 2 --timeout 2m --metrics

すべてのストレッサーの 2 つの同時インスタンスを XNUMX つずつ順番に実行します。
2 分で最後にパフォーマンス指標をまとめます。

ストレス-ng --cpu 4 --cpu-method fft --cpu-ops 10000 --metrics-brief

4 つの FFT CPU ストレッサーを実行し、10000 回のボゴ操作後に停止し、概要を生成します
FFT 結果のみ。

ストレス-ng --cpu 0 --cpu-method all -t 1h

利用可能なすべての CPU を通じて動作するすべてのオンライン CPU で CPU ストレッサーを実行します。
ストレス要因を1時間。

ストレス-ng --all 4 --timeout 5m

すべてのストレッサーの 4 つのインスタンスを 5 分間実行します。

ストレスNG --ランダム 64

利用可能なすべてのストレッサーからランダムに選択された 64 個のストレッサーを実行します。

ストレス-ng --cpu 64 --cpu-method all --verify -t 10m --metrics-brief

すべての異なる CPU ストレス要因の 64 個のインスタンスを実行し、
計算は 10 分間正しく行われ、最後にボゴ操作の概要が表示されます。

ストレス-ng --sequential 0 -t 10m

すべてのストレッサーを 10 分間、インスタンスの数で XNUMX つずつ実行します。
各ストレッサーはオンライン CPU の数と一致します。

ストレス-ng --sequential 8 --class io -t 5m --times

io クラス内のすべてのストレッサーを 5 つずつ 8 分間、XNUMX 個で実行します。
同時に実行されている各ストレッサーのインスタンスと全体の時間使用率を表示
実行終了時の統計。

ストレス-ng --all 0 --maximize --aggressive

すべてのストレッサー (CPU ごとに 1 つのインスタンス) を同時に実行し、
設定 (メモリ サイズ、ファイル割り当てなど) を選択し、最も多くの値を選択します。
要求の厳しい/攻撃的なオプション。

ストレス-ng --ランダム 32 -x 沼、hdd、キー

ランダムに選択された 32 個のストレッサーを実行し、NUMA、HDD、および主要なストレッサーを除外します

tress-ng --sequential 4 --class vm --bigheap、brk、stack を除外

VM ストレッサーの 4 つのインスタンスを順番に実行します (ビッグヒープを除く)。
BRK とスタック ストレッサー

EXIT ステータス

ステータス 詳細説明
0成功。
1 エラー。 間違ったユーザー オプションまたはストレス ng の致命的なリソースの問題
ストレッサー ハーネス (メモリ不足など)。
2 XNUMX つ以上のストレッサーが失敗しました。
3 リソース不足のため、XNUMX つ以上のストレッサーの初期化に失敗しました。
例としては、ENOMEM (メモリなし) および ENOSPC (ファイル システムにスペースなし) があります。

onworks.net サービスを使用してオンラインでストレス NG を使用する