regorge - En ligne dans le cloud

PROGRAMME:

Nom

crache - mesure les performances d'E/S et/ou génère une charge d'E/S

SYNOPSIS

vomir --écrire|--lire|--lire-après-écrire [OPTION] ... TRANSFER_SIZE[kKmMgG] DOSSIER

DESCRIPTION

Un outil de mesure des performances d'E/S et de génération de charge. Écritures et/ou lectures générées
données vers ou depuis un périphérique de caractères, un périphérique de bloc ou un fichier normal.

-B, --max-taille-tampon=BUFFER_SIZE
Chaque lire(2) /écrire(2) l'appel utilise un tampon maximum de taille BUFFER_SIZE.

-b, --min-taille-tampon=BUFFER_SIZE
Chaque lire(2) /écrire(2) l'appel utilise un tampon minimum de taille BUFFER_SIZE.

-c, --continue-après-erreur
Continuer après les erreurs d'intégrité des données.

-d, --direct
Utilisez les E/S directes. Ne doit être utilisé que sur les fichiers de périphérique de bloc. Tous ne fonctionnent pas
les systèmes prennent en charge les E/S directes

-g, --generate-charge
Équivalent à: -v -t -P -p aléatoire -i 0.

-i, --itérations=COUNT
Écrire/lire les données COUNT fois. Si count est 0, se répète indéfiniment.

-l, --fichier journal=FICHIER JOURNAL
Envoyez des messages de journal à LOGFILE.

--pas de progrès
Ne pas afficher la progression (par défaut).

--no-rcfiles
N'utilisez pas de fichiers rc standard.

-q, --pas de statistiques
Ne publiez pas de statistiques.

--pas de tui
N'utilisez pas l'interface TUI.

-o, --décalage=OFFSET
Cherchez à OFFSET avant de démarrer les E/S.

-P, --le progrès
Montrer les progrès.

-p, --modèle=RECONNAISSANCE
Utilisez le modèle de données PATTERN lors de la lecture ou de l'écriture de données.

-r, --Aléatoire
Tampons de lecture/écriture sur des décalages aléatoires.

--cru Un alias pour --lecture après écriture.

--rcfile=FICHIER RC
Lisez les options de ligne de commande à partir de RCFILE.

--lire Lire la date dans FILE.

--lecture après écriture
Relisez les données après avoir écrit dans FILE.

-S, --la graine=
Utilisez SEED pour une graine de nombre aléatoire.

-s, --sync
Utilisez des E/S synchrones.

--statistiques
Statistiques de sortie (par défaut).

-t, --tui
Utilisez une interface utilisateur de terminal basée sur les malédictions.

-u, --unités=UNITÉS
Afficher le taux de transfert en unités UNITS.

--usage
Afficher un bref message d'utilisation et quitter.

-V, --version
Affiche les informations de version et quitte.

-v, --statistiques-détaillées
Sortir des statistiques détaillées.

--écrivez
Écrire des données dans FILE.

- ?, --Aidez-moi
Affichez cette aide et quittez.

FILE Fichier normal ou fichier de périphérique dans lequel écrire les données.

FICHIER JOURNAL
Chemin d'accès à un fichier utilisé pour la journalisation.

MAX_BUFFER_SIZE
Taille de mémoire tampon minimale utilisée dans chaque lire(2) /écrire(2) appel (la valeur par défaut est MIN_BUFFER_SIZE
octets). MAX_BUFFER_SIZE. Doit être un multiple pair de 512 octets et peut être
spécifié en octets, kibioctets(k), kilo-octets(K), mebioctets(m), mégaoctets (M),
gibioctets(g), gigaoctets(G). tebioctets(t) ou téraoctets(T). MAX_BUFFER_SIZE
la valeur par défaut est MIN_BUFFER_SIZE. Si MAX_BUFFER_SIZE > MIN_BUFFER_SIZE, tampons aléatoires
des tailles comprises entre les deux limites sont utilisées. MAX_BUFFER_SIZE doit être un multiple pair de
MIN_BUFFER_SIZE.

MIN_BUFFER_SIZE
Taille de mémoire tampon minimale utilisée dans chaque lire(2) /écrire(2) appel (la valeur par défaut est de 512 octets).
MIN_BUFFER_SIZE. Doit être un multiple pair de 512 octets et peut être spécifié dans
octets, kibioctets(k), kilooctets(K), mebioctets(m), mégaoctets(M), gibioctets(g),
gigaoctets (G). tebioctets(t) ou téraoctets(T).

OFFSET Position à rechercher dans le fichier avant de démarrer les E/S (la valeur par défaut est 0). L'OFFSET doit être
un multiple pair de 512 octets et peut être spécifié en octets, kibioctets (k),
kilo-octets (K), mebioctets(m), mégaoctets(M), gibioctets(g), gigaoctets(G).
tebioctets(t) ou téraoctets(T).

RECONNAISSANCE
Modèle de données utilisé lors de l'écriture/lecture des données. Les modèles disponibles sont : aucun, zéros,
ones, alt, random, numbers et "#" (où "#" est un nombre compris entre 0 et 255). Les
le modèle par défaut est "aucun".

RCFILE Lit des options de ligne de commande supplémentaires à partir de RCFILE. D'autres options sur le
la ligne de commande remplacera les options de RCFILE.

SEED Utilisé pour amorcer le générateur de nombres aléatoires Doit être >= 1 et <= 2^32.

TRANSFER_SIZE
Nombre total d'octets à transférer (doit être un multiple pair des deux MIN_BUFFER_SIZE
et MAX_BUFFER)SIZE). TRANSFER_SIZE peut être spécifié en octets, kilo-octets,
mégaoctets ou gigaoctets.

UNITÉS Kibioctets(k), kilooctets(K), mebioctets(m), mégaoctets(M), gibioctets(g), gigaoctets(G).
tebioctets(t) ou téraoctets(T).

EXEMPLES

vomir --écrivez -b 16K 1m / tmp / bigfile

or

vomir -b 16K 1m / tmp / bigfile

Écrit 1 mebioctet (1 mebioctet = 1024*1024 octets) en utilisant 16 kibioctets (1 kibioctet = 1024
octets) demandes au fichier / tmp / bigfile en utilisant le modèle par défaut (aléatoire). Affiche le
taux de transfert d'écriture en kibioctets par seconde et temps de transfert d'écriture en secondes.

vomir --écrivez -u m -i 10 -b 1k 256K / Dev / sda1

or

vomir -u m -i 10 -b 1k 256K / Dev / sda1

Écrit 256 kibioctets à l'aide de requêtes de 1 kibioctet dans le fichier de périphérique de bloc / Dev / sda1 10 fois
en utilisant le modèle par défaut (aléatoire). Les taux de transfert d'itération et d'écriture cumulés sont
affiché en mebioctets par seconde et les temps de transfert d'itération et d'écriture cumulés
sont affichés en secondes.

vomir --cru -d -o 1m -b 16m 1g / tmp / bigfile

or

regorger -s -o 1m -b 16m 1g / tmp / bigfile

Écrire 1 gibioctet (1 gibioctet = 1024*1024*1024 octets) en commençant à un décalage de 1 mebioctet
en utilisant des requêtes de 16 mégaoctets au fichier / tmp / bigfile en utilisant le modèle par défaut (aléatoire).
Les données sont écrites de manière synchrone et vidées à la fermeture du fichier. Ensuite, lisez les mêmes données
en utilisant la même taille de requête et le même décalage. Les données sont vérifiées pour s'assurer que les données lues
in correspond aux données lues. Les taux de transfert d'écriture et de lecture sont affichés dans
kibioctets/seconde. Les temps de transfert de lecture et d'écriture sont affichés en secondes.

vomir --lire -i 0 -u M -p zéros -b 512 1m /dev/zéro

or

gorge -i 0 -u M -p zéros -b 512 1m /dev/zéro

Lire 1 mebioctet de données à l'aide de requêtes de 512 octets à partir du fichier /dev/zéro un nombre infini
de fois en utilisant le modèle de zéros (ne pas vérifier les données). L'itération et le cumul
les taux de transfert de lecture sont affichés en mégaoctets (1 mégaoctet = 1,000,000 XNUMX XNUMX octets) par seconde
et les temps d'itération et de transfert de lecture cumulés sont affichés en secondes.

vomir --cru -g -r -b 1k -B 256K 1t /dev/md1

or

regorger -g -r -b 1k -B 256K 1t /dev/md1

Ecrivez 1 tébioctet (1 tébioctet = 1024*1024*1024*1024 octets) en utilisant des requêtes de 1-256 kibioctet à
le dispositif de bloc /dev/md1 en utilisant le modèle aléatoire. Les recherches aléatoires sont effectuées avant
chaque transfert, mais chaque bloc entre le début et la fin des données est écrit exactement
une fois que. Les tailles des requêtes sont choisies au hasard. Ensuite, lisez les mêmes données en utilisant le même
taille des requêtes et recherche dans le même ordre. Répétez la séquence ci-dessus un infini
nombre de fois jusqu'à ce qu'on lui demande de quitter (via un signal ou une commande TUI).

Les données sont vérifiées pour s'assurer que les données lues correspondent aux données lues. Une malédiction-
TUI basé est utilisé pour afficher les taux d'itération et de transfert cumulés, les temps de transfert et
octets transférés. Afficher les statistiques détaillées après avoir quitté.

ALGORITHMES

L'algorithme suivant est utilisé pour déterminer la taille du bloc lorsque MAX_BUFFER_SIZE >
MIN_BUFFER_SIZE :

Trouvez la plus grande taille de bloc qui est une puissance de 2 et est >= MAX_BUFFER_SIZE. Appelez ceci
maxbuffersize. Trouvez la plus petite taille de tampon qui est une puissance de 2 et est >=
MIN_BUFFER_SIZE. Appelez ce minbuffersize. Chunksize = maxbuffersize * (différence dans
nombre de bits entre min et maxbuffersize + 1). Le nombre de morceaux est
TRANSFER_SIZE/taille de morceau. Appelez ça numchunks. Il y aura un nombre de nombres de
lectures/écritures de taille maxbuffersize, 2 * numchunks nombre de lectures/écritures
de taille maxbuffersize/2, 4 * numchunks nombre de lectures/écritures de taille
maxbuffersize/4, et ainsi de suite jusqu'à ce que minbuffersize soit atteint. MIN_BUFFER_SIZE est utilisé pour
tous les transferts restants si TRANSFER_SIZE n'est pas également divisible par chunksize.

Exemple : Utilisation d'un MIN_BLOCK_SIZE de 1k, un MAX_BLOCK_SIZE de 8k et un TRANSFER_SIZE de 264k
résultats en 8 8k lectures/écritures, 16 4k lectures/écritures, 32 2k lectures/écritures et 64 + 8 1k
lecture/écriture.

MOTIFS

Utilisez le suivant od(1) commande pour examiner les fichiers générés par vomissement où une intégrité des données
un problème est survenu :

od -A d --format=d8 --width=32

Utilisez regorge en ligne en utilisant les services onworks.net