fio - Online nel cloud

PROGRAMMA:

NOME

fio - tester I/O flessibile

SINOSSI

filo [Opzioni] [file di lavoro] ...

DESCRIZIONE

filo è uno strumento che genererà un numero di thread o processi che eseguono un particolare tipo di
Azione di I/O come specificato dall'utente. L'uso tipico di fio è scrivere un file di lavoro
corrispondenza del carico di I/O che si vuole simulare.

VERSIONI

- debug=Digitare
Abilita la traccia dettagliata di varie azioni fio. Può essere "tutto" per tutti i tipi o
singoli tipi separati da una virgola (es. --debug=io,file). "aiuto" elencherà tutto
opzioni di tracciamento disponibili.

--produzione=Nome del file
Scrivi output su Nome del file.

--formato di output=formato
Imposta il formato del rapporto su normale, conciso, o json.

--tempo di esecuzione=runtime
Limita il tempo di esecuzione a runtime secondi.

--log larghezza di banda
Genera log di larghezza di banda per lavoro.

--minimo
Stampa le statistiche in un formato conciso e delimitato da punto e virgola.

--appendere-conciso
Stampa le statistiche nella modalità selezionata E nel formato conciso, delimitato da punto e virgola.

--versione
Visualizza le informazioni sulla versione ed esci.

--versione-concisa=versione
Imposta il formato di output della versione concisa (versione corrente 3 o versione precedente 2).

--Aiuto Visualizza le informazioni sull'utilizzo ed esci.

--cpuclock-test
Eseguire test e convalida dell'orologio della CPU interna

--crtest[=test]
Testare la velocità delle funzioni di checksum integrate. Se non viene fornito alcun argomento, all
di loro sono testati. Oppure può essere passato un elenco separato da virgole, nel qual caso il
quelli dati sono testati.

--cmdaiuto=command
Stampa le informazioni della guida per command. Può essere "tutto" per tutti i comandi.

--enghelp=ioengine[,comando]
Elenca tutti i comandi definiti da iomotore, o stampa la guida per command definito da
iomotore.

--showcmd=file di lavoro
convertire file di lavoro a una serie di opzioni della riga di comando.

--eta=quando
Specifica quando deve essere stampata la stima dell'ETA in tempo reale. quando potrebbe essere uno di
"sempre", "mai" o "auto".

--eta-nuova riga=tempo
Forza una nuova riga ETA per ogni periodo di `tempo` trascorso.

--stato-intervallo=tempo
Riporta lo stato di output completo ogni periodo di "tempo" trascorso.

--sola lettura
Attiva i controlli di sola lettura di sicurezza, impedendo qualsiasi tentativo di scrittura.

--sezione=asciutto
Solo sezione corsa asciutto dal file di lavoro. Questa opzione può essere utilizzata più volte per aggiungere
più sezioni da eseguire.

--dimensione alloc=kb
Imposta la dimensione della piscina interna di Smalloc su kb kilobyte.

--avvertimenti-fatale
Tutti gli avvertimenti del parser fio sono fatali, causando l'uscita di fio con un errore.

--max-lavori=nr
Imposta il numero massimo consentito di lavori (thread/processi) da supportare.

--server=args
Avvia un server di backend, con args specificando cosa ascoltare. Vedi client/server
.

--demonizzare=file pid
Sottofondo un server fio, scrivendo il pid nel file pid specificato.

--cliente=host
Invece di eseguire i lavori localmente, inviali ed eseguili sull'host o sul set di dati specificato
padroni di casa. Vedere la sezione client/server.

--idle-prof=opzione
Segnala l'inattività della CPU a livello di sistema o percpu (opzione=sistema,percpu) o esegui unità
solo calibrazione di lavoro (opzione=calibrare).

JOB RISORSE FORMATO

I file di lavoro sono in formato 'ini'. Consistono in una o più definizioni di lavoro, che iniziano
con un nome del lavoro tra parentesi quadre ed estenderlo al nome del lavoro successivo. Il nome del lavoro può essere
qualsiasi stringa ASCII eccetto `global', che ha un significato speciale. Dopo il nome del lavoro è
una sequenza di zero o più parametri, uno per riga, che definiscono il comportamento del lavoro.
Qualsiasi riga che inizia con un `;' o il carattere "#" è considerato un commento e ignorato.

If file di lavoro è specificato come `-', il file di lavoro verrà letto dallo standard input.

globali Sezione
La sezione globale contiene i parametri predefiniti per i lavori specificati nel file di lavoro. Un lavoro
è influenzato solo dalle sezioni globali che risiedono sopra di esso e potrebbe esserci un numero qualsiasi di
sezioni globali. Definizioni di lavoro specifiche possono sovrascrivere qualsiasi set di parametri in global
.

JOB PARAMETRI

Tipi
Alcuni parametri possono accettare argomenti di un tipo specifico. Ovunque un valore numerico è
richiesto, può essere utilizzata un'espressione aritmetica, purché racchiusa tra parentesi.
Gli operatori supportati sono:

aggiunta (+)

sottrazione (-)

moltiplicazione (*)

divisione ,

modulo (%)

elevamento a potenza (^)

Per i valori temporali nelle espressioni, le unità sono i microsecondi per impostazione predefinita. Questo è diverso da
per i valori temporali non nelle espressioni (non racchiusi tra parentesi). Le tipologie utilizzate sono:

str Stringa: una sequenza di caratteri alfanumerici.

int SI intero: un numero intero, eventualmente contenente un suffisso che denota l'unità base di
il valore. I suffissi accettati sono "k", "M", "G", "T" e "P", che indicano chilo
(1024), mega (1024^2), giga (1024^3), tera (1024^4) e peta (1024^5)
rispettivamente. Se preceduto da '0x', si presume che il valore sia in base 16
(esadecimale). Un suffisso può includere una "b" finale, ad esempio "kb" è identico
a 'k'. È possibile specificare un valore di base 10 utilizzando 'KiB', 'MiB', 'GiB', ecc.
utile per le unità disco in cui i valori sono spesso dati in valori in base 10. Specificando
'30GiB' ti darà 30*1000^3 byte. Quando si specificano le volte il suffisso predefinito
cambiamenti di significato, che denotano ancora l'unità di base del valore, ma suffissi accettati
sono 'D' (giorni), 'H' (ore), 'M' (minuti), 'S' Secondi, 'ms' (o msec) milli
secondi, 'us' (o 'usec') microsecondi. I valori temporali senza un'unità specificano
secondi. I suffissi non fanno distinzione tra maiuscole e minuscole.

bool Booleano: un valore vero o falso. "0" indica falso, "1" indica vero.

arancione Intervallo intero: un intervallo di numeri interi specificati nel formato abbassarla:superiore or
abbassarla-superiore. abbassarla e superiore può contenere un suffisso come descritto sopra. Se un'opzione
consente due insiemi di intervalli, sono separati da un carattere `,' o `/'. Per
esempio: `8-8k/8M-4G'.

float_list
Elenco di numeri mobili: un elenco di numeri mobili, separati da un carattere ':'.

Parametro Lista
Nome=str
Può essere utilizzato per sovrascrivere il nome del lavoro. Sulla riga di comando, questo parametro ha il
scopo speciale di segnalare l'inizio di un nuovo lavoro.

descrizione=str
Descrizione leggibile del lavoro. Viene stampato quando il lavoro viene eseguito, ma
altrimenti non ha uno scopo speciale.

elenco=str
Prefissa i nomi dei file con questa directory. Utilizzato per posizionare i file in una posizione diversa da
`./'. Puoi specificare un numero di directory separando i nomi con un ':'
carattere. Queste directory verranno assegnate equamente distribuite ai cloni di lavoro
crea con num lavori purché utilizzino nomi di file generati. Se specifico
nome/i file sono impostati fio utilizzerà la prima directory elencata, e quindi corrisponderà
, il Nome del file semantico che genera un file ogni clone se non specificato, ma lascia
tutti i cloni usano lo stesso se impostato. Vedere Nome del file per considerazioni sulla fuga
alcuni personaggi su alcune piattaforme.

Nome del file=str
filo normalmente compone un nome file in base al nome del lavoro, al numero del thread e al file
numero. Se desideri condividere file tra thread in un lavoro o più lavori,
specifica a Nome del file per ciascuno di essi per sovrascrivere l'impostazione predefinita. Se il motore I/O è
basato su file, puoi specificare un numero di file separando i nomi con un `:'
carattere. "-" è un nome riservato, che significa stdin o stdout, a seconda del
direzione di lettura/scrittura impostata. Su Windows, si accede ai dispositivi disco come \.PhysicalDrive0
per il primo dispositivo, \.PhysicalDrive1 per il secondo ecc. Nota: Windows e
FreeBSD impedisce l'accesso in scrittura ad aree del disco che contengono dati in uso (es
filesystem). Se il nome del file desiderato deve includere i due punti, allora esegui l'escape
con un carattere '\'. Ad esempio, se il nome del file è "/dev/dsk/foo@3,0:c", allora
useresti filename="/dev/dsk/foo@3,0\:c".

nome_file_formato=str
Se si condividono più file tra lavori, di solito è necessario avere fio
generare i nomi esatti che si desidera. Per impostazione predefinita, fio nominerà un file in base a
la specifica del formato file predefinito di nomelavoro.numerolavoro.numerofile. Con questo
opzione, che può essere personalizzata. Fio riconoscerà e sostituirà quanto segue
parole chiave in questa stringa:

$nomelavoro
Il nome del thread di lavoro o del processo.

$numero di lavoro
Il numero incrementale del thread di lavoro o del processo.

$numerofile
Il numero incrementale del file per quel thread o processo di lavoro.

Per fare in modo che i lavori dipendenti condividano un insieme di file, questa opzione può essere impostata per avere fio
generare nomi di file condivisi tra i due. Ad esempio, se
file di prova.$numerofile è specificato, verrà nominato il numero di file 4 per qualsiasi lavoro
file di prova.4. Il valore predefinito di $nomelavoro.$numerolavoro.$numerofile verrà utilizzato se non altro
viene fornito l'identificatore di formato.

file di blocco=str
Fio per impostazione predefinita non blocca alcun file prima di eseguire l'IO su di essi. Se un file o un file
il descrittore è condiviso, fio può serializzare IO su quel file per ottenere il risultato finale
coerente. Questo è normale per emulare carichi di lavoro reali che condividono file. La serratura
le modalità sono:

nessuna Nessun blocco. Questa è l'impostazione predefinita.

esclusivo
Solo un thread o processo può eseguire l'IO alla volta, escludendo tutti gli altri.

leggere scrivere
Blocco in lettura-scrittura sul file. Molti lettori possono accedere al file su
allo stesso tempo, ma le scritture ottengono l'accesso esclusivo.

aperto dir=str Apri ricorsivamente tutti i file sotto la directory str.

leggere scrivere=str, rw=str
Tipo di schema I/O. I valori accettati sono:

read Letture sequenziali.

scrivere Scritture sequenziali.

tagliare Trim sequenziale (solo dispositivi a blocchi Linux).

randread
Letture casuali.

riscrivi
Scritture casuali.

randtrim
Trim casuale (solo dispositivi a blocchi Linux).

RW, leggere scrivere
Letture e scritture sequenziali miste.

randw Letture e scritture casuali miste.

riscrivi
Taglia e scrivi carichi di lavoro misti. I blocchi verranno prima tagliati, poi il
verranno scritti gli stessi blocchi.

Per l'I/O misto, la suddivisione predefinita è 50/50. Per alcuni tipi di io il risultato potrebbe
essere ancora un po' distorto, poiché la velocità potrebbe essere diversa. È possibile specificare
un certo numero di IO da fare prima di ottenere un nuovo offset, questo viene fatto aggiungendo a
`: alla fine della stringa data. Per una lettura casuale, sembrerebbe
rw=lettura:8 per aver passato un modificatore di offset con un valore di 8. Se il suffisso
viene utilizzato con un pattern IO sequenziale, quindi il valore specificato verrà aggiunto a
offset generato per ogni IO. Ad esempio, usando rw=scrivi:4k salterà 4k per
ogni scrittura. Trasforma l'IO sequenziale in IO sequenziale con buchi. Vedi il
rw_sequencer opzione.

rw_sequencer=str
Se viene fornito un modificatore di offset aggiungendo un numero al rw= linea, quindi
questa opzione controlla come quel numero modifica l'offset IO che viene generato.
I valori accettati sono:

sequenziale
Genera offset sequenziale

identico
Genera lo stesso offset

sequenziale è utile solo per IO casuale, dove normalmente fio genererebbe un nuovo
offset casuale per ogni IO. Se aggiungi ad esempio 8 a randread, otterrai un nuovo
offset casuale per ogni 8 IO. Il risultato sarebbe una ricerca solo per ogni 8 IO,
invece che per ogni IO. Uso rw=lettura:8 per specificarlo. Poiché l'IO sequenziale è
già sequenziale, impostazione sequenziale perché ciò non comporterebbe nessuno
differenze. identico si comporta in modo simile, tranne che invia lo stesso
offset 8 volte prima di generare un nuovo offset.

kb_base=int
L'unità di base per un kilobyte. La base di fatto è 2^10, 1024. Archiviazione
i produttori preferiscono invece usare 10^3 o 1000 come unità di base dieci, per ovvio
motivi. I valori consentiti sono 1024 o 1000, con 1024 come predefinito.

unified_rw_reporting=bool
Fio normalmente riporta le statistiche in base alla direzione dei dati, il che significa che leggere,
write e trim sono contabilizzati e riportati separatamente. Se questa opzione è impostata fio
somma i risultati e li riporta invece come "misti".

ripetere=bool
Semina il generatore di numeri casuali utilizzato per i modelli di I/O casuali in modo prevedibile
quindi il modello è ripetibile tra le serie. Predefinito: vero.

allrandrepeat=bool
Semina tutti i generatori di numeri casuali in modo prevedibile in modo che i risultati siano ripetibili
attraverso le corse. Predefinito: falso.

semi di rana=int
Semina i generatori di numeri casuali in base a questo valore seme, per essere in grado di controllare
quale sequenza di output viene generata. Se non è impostata, la sequenza casuale dipende
sul canale ripetere impostazione.

fallocare=str
Se la pre-allocazione viene eseguita durante l'impostazione dei file. I valori accettati sono:

nessuna Non preallocare lo spazio.

posix Pre-allocare tramite posix_fallocate(3).

mantenere Pre-allocare tramite fallocare(2) con FALLOC_FL_KEEP_SIZE impostato.

0 Alias ​​compatibile con le versioni precedenti per "nessuno".

1 Alias ​​retrocompatibile per 'posix'.

Potrebbe non essere disponibile su tutte le piattaforme supportate. 'mantieni' è disponibile solo su Linux.
Se si utilizza ZFS su Solaris, questo deve essere impostato su "none" perché ZFS non lo supporta.
Predefinito: 'posix'.

fadvise_hint=bool
Usa il posix_fadvise(2) per avvisare il kernel quali sono probabilmente i pattern di I/O
rilasciato. Predefinito: vero.

fadvise_stream=int
Usa il posix_fadvise(2) per avvisare il kernel a quale stream ID appartengono le scritture emesse
a. Supportato solo su Linux. Nota, questa opzione potrebbe cambiare in futuro.

Taglia=int
Dimensione totale di I/O per questo lavoro. filo funzionerà fino a quando non saranno stati superati questi byte
trasferiti, a meno che non siano limitati da altre opzioni (runtime, ad esempio, o
aumentato/diminuito di io_dimensione). Salvo che nrfile e dimensione del file le opzioni sono date,
tale importo verrà diviso tra i file disponibili per il lavoro. Se non impostato,
fio utilizzerà l'intera dimensione dei file o dei dispositivi forniti. Se i file non lo fanno
esiste, la dimensione deve essere data. È anche possibile dare la dimensione come percentuale tra
1 e 100. Se viene fornito size=20%, fio utilizzerà il 20% della dimensione completa del dato
file o dispositivi.

io_dimensione=int, io_limite =int
Normalmente fio opera all'interno della regione impostata da Taglia, Il che significa che l' Taglia
L'opzione imposta sia la regione che la dimensione dell'IO da eseguire. A volte non lo è
ciò che vuoi. Con questa opzione è possibile definire solo la quantità di IO
che fio dovrebbe fare. Ad esempio, se Taglia è impostato su 20G e io_limite è impostato su 5G,
fio eseguirà IO entro i primi 20G ma uscirà quando il 5G sarà terminato. Il
è anche possibile il contrario - se Taglia è impostato su 20G, e io_dimensione è impostato su 40G, quindi
fio eseguirà 40G di IO all'interno della regione 0..20G.

riempimento_dispositivo=bool, fill_fs=bool
Imposta le dimensioni su qualcosa di veramente grande e attende ENOSPC (nessun spazio lasciato sul dispositivo)
come condizione risolutiva. Ha senso solo con la scrittura sequenziale. Per una lettura
carico di lavoro, il punto di montaggio verrà riempito prima, quindi IO avviato sul risultato. Questo
l'opzione non ha senso se si opera su un nodo del dispositivo non elaborato, poiché la dimensione di questo
è già noto al file system. Inoltre, scrivere oltre la fine del dispositivo
non restituirà ENOSPC lì.

dimensione del file=arancione
Dimensioni file individuali. Può essere un intervallo, nel qual caso filo selezionerà le taglie per
file a caso all'interno dell'intervallo dato, limitato a Taglia in totale (se questo è
dato). Se dimensione del file non è specificato, ogni file creato ha la stessa dimensione.

file_append=bool
Esegui IO dopo la fine del file. Normalmente fio funzionerà entro le dimensioni di
un file. Se questa opzione è impostata, fio verrà invece aggiunto al file. Questo ha
comportamento identico all'impostazione dell'offset alla dimensione di un file. Questa opzione viene ignorata
su file non regolari.

misura del blocco=int[,int], bs=int[,int]
Dimensione del blocco per le unità di I/O. Predefinito: 4k. I valori per letture, scritture e trim possono essere
specificato separatamente nel formato read,scrivere,tagliare uno dei quali può essere vuoto per
lascia quel valore al suo valore predefinito. Se non viene data una virgola finale, il resto
erediterà l'ultimo valore impostato.

intervallo_dimensioni_blocco=arancio[,arancio], bsrange=arancio[,arancio]
Specificare un intervallo di dimensioni del blocco I/O. L'unità di I/O emessa sarà sempre un multiplo
della dimensione minima, a meno che blocksize_non allineato è impostato. Si applica a entrambe le letture e
scrive se viene fornito un solo intervallo, ma può essere specificato separatamente con una virgola
separare i valori. Esempio: bsrange=1k-4k,2k-8k. Vedi anche misura del blocco).

bssplit=str
Questa opzione consente un controllo ancora più preciso delle dimensioni dei blocchi emessi, non solo
addirittura si divide tra di loro. Con questa opzione, puoi pesare blocchi di varie dimensioni per
controllo esatto dell'IO emesso per un lavoro con dimensioni di blocco miste. Il formato di
l'opzione è bssplit=blocksize/percentage, aggiungendo facoltativamente tante definizioni
se necessario separati da due punti. Esempio: bssplit=4k/10:64k/50:32k/40 verrebbe emesso
50% 64k blocchi, 10% 4k blocchi e 40% 32k blocchi. bssplit supporta anche il dare
separazioni separate per letture e scritture. Il formato è identico a quello del bs opzione
accetta, le parti di lettura e scrittura sono separate da una virgola.

blocksize_non allineato, bs_non allineato
Se impostato, qualsiasi dimensione in intervallo_dimensioni_blocco può essere usato. Questo in genere non funziona con
I/O diretto, poiché normalmente richiede l'allineamento del settore.

blockalign=int[,int], ba=int[,int]
A quale limite allineare gli offset IO casuali. Il valore predefinito è lo stesso di "blocksize"
la dimensione minima del blocco data. L'allineamento minimo è in genere 512b per l'utilizzo diretto
IO, sebbene di solito dipenda dalla dimensione del blocco hardware. Questa opzione è reciprocamente
esclusivo con l'utilizzo di una mappa casuale per i file, quindi disattiverà quell'opzione.

bs_is_seq_rand=bool
Se questa opzione è impostata, fio utilizzerà le normali impostazioni di lettura e scrittura delle dimensioni dei blocchi come
sequenziale, invece casuale. Qualsiasi lettura o scrittura casuale utilizzerà la dimensione del blocco WRITE
impostazioni e qualsiasi lettura o scrittura sequenziale utilizzerà l'impostazione READ blocksize.

zero_buffer
Inizializza i buffer con tutti gli zeri. Predefinito: riempire i buffer con dati casuali.

fill_buffers
Se viene data questa opzione, fio riempirà i buffer IO ad ogni invio. Il
l'impostazione predefinita è riempirlo solo al momento dell'inizializzazione e riutilizzare quei dati. Ha senso solo se
zero_buffers non è specificato, naturalmente. Se la verifica dei dati è abilitata,
refill_buffers è anche abilitato automaticamente.

scramble_buffers=bool
If fill_buffers è troppo costoso e l'obiettivo utilizza la deduplicazione dei dati, quindi
l'impostazione di questa opzione modificherà leggermente il contenuto del buffer IO per sconfiggere il normale
tentativi di de-duplica. Questo non è abbastanza per sconfiggere la compressione dei blocchi più intelligente
tentativi, ma fermerà la deduplicazione ingenua dei blocchi. Predefinito: vero.

buffer_compress_percentuale=int
Se è impostato, fio tenterà di fornire il contenuto del buffer IO (su WRITE) che
comprimere al livello specificato. Fio lo fa fornendo un mix di dati casuali
e uno schema fisso. Il modello fisso è o zero o il modello specificato
by modello_buffer. Se viene utilizzata l'opzione pattern, potrebbe distorcere la compressione
rapporto leggermente. Nota che questo è per unità di dimensione del blocco, per file/disco wide
livello di compressione che corrisponde a questa impostazione. Nota che questo è per unità di dimensione del blocco,
per il livello di compressione a livello di file/disco che corrisponde a questa impostazione, ti consigliamo anche
imposta refill_buffers.

buffer_compress_chunk=int
See buffer_compress_percentuale. Questa impostazione consente a fio di gestire la dimensione del
intervalli di dati casuali e dati azzerati è. Senza questo set, fio fornirà
buffer_compress_percentuale di dati casuali blocksize, seguiti dai restanti
azzerato. Con questo set a una dimensione del blocco più piccola della dimensione del blocco, fio può
alternare dati casuali e azzerati in tutto il buffer IO.

modello_buffer=str
Se impostato, fio riempirà i buffer IO con questo pattern. Se non è impostato, il contenuto di
I buffer IO sono definiti dalle altre opzioni relative al contenuto del buffer. Le impostazioni
può essere qualsiasi modello di byte e può essere preceduto da 0x per i valori esadecimali. Esso può
anche essere una stringa, dove la stringa deve poi essere racchiusa con "", ad esempio:
modello_buffer="abcd"
or
modello_buffer= -12
or
modello_buffer=0xfaccia morta

Inoltre puoi combinare tutto insieme in qualsiasi ordine:

modello_buffer=0xdeadface"abcd"-12

dedupe_percentuale=int
Se impostato, fio genererà questa percentuale di buffer identici durante la scrittura. Queste
i buffer saranno naturalmente deduplicabili. Il contenuto dei buffer dipende da cosa
sono state impostate altre impostazioni di compressione del buffer. E' possibile avere il
i singoli buffer sono completamente comprimibili o non lo sono affatto. Solo questa opzione
controlla la distribuzione di buffer univoci.

nrfile=int
Numero di file da utilizzare per questo lavoro. Predefinito: 1.

file aperti=int
Numero di file da tenere aperti contemporaneamente. Predefinito: nrfile.

tipo_servizio_file=str
Definisce come vengono selezionati i file da servire. Sono definite le seguenti tipologie:

con Scegli un file a caso.

RoundRobin
Round robin sui file aperti (impostazione predefinita).

sequenziale
Esegui ogni file nel set in sequenza.

Il numero di I/O da emettere prima di passare a un nuovo file può essere specificato da
aggiungendo `:int' al tipo di servizio.

iomotore=str
Definisce come il lavoro emette l'I/O. Sono definite le seguenti tipologie:

sync Basic read(2) o scrivere(2) ingresso/uscita. cerca(2) viene utilizzato per posizionare l'I/O
posizione.

psinc Basic predetto(2) o scrivere(2) ingresso/uscita.

vsync Basic leggi(2) o scrivivi(2) I/O. Emulerà la coda fondendosi
IO adiacenti in un'unica sottomissione.

pvsync Basic anticipato(2) o scrivere(2) ingresso/uscita.

libio I/O asincrono nativo di Linux. Questo motore definisce le specifiche del motore
opzioni.

posixio
I/O asincrono POSIX utilizzando aio_read(3) e aio_scrivi(3).

solarisaio
I/O asincrono nativo di Solaris.

windowsio
I/O asincrono nativo di Windows.

mmap Il file è mappato in memoria con mmap(2) e dati copiati usando memcpy(3).

giunzione giunzione(2) viene utilizzato per trasferire i dati e vmsplice(2) trasferire
dati dallo spazio utente al kernel.

syslet-rw
Utilizzare le chiamate di sistema syslet per rendere asincrona la lettura/scrittura regolare.

sg SCSI generico sg v3 I/O. Può essere sincrono utilizzando SG_IO
ioctl, o se il target è un dispositivo a caratteri sg, usiamo read(2) e
scrivere(2) per I/O asincrono.

nullo Non trasferisce alcun dato, fa solo finta di farlo. Utilizzato principalmente per l'esercizio
filo stesso e per scopi di debug e test.

rete Trasferimento in rete. Il protocollo da utilizzare può essere definito
con la protocollo parametro. A seconda del protocollo, Nome del file,
hostname, porto, o ascolta deve essere specificato. Questo ioengine definisce
opzioni specifiche del motore.

netsplice
Come rete, ma usa giunzione(2) e vmsplice(2) per mappare i dati e
invia Ricevi. Questo ioengine definisce le opzioni specifiche del motore.

CPU Non trasferisce alcun dato, ma brucia i cicli della CPU in base a cpuload
e cpucycles parametri.

Sicuro Il motore di I/O GUASI è il Generic Userspace Asynchronous Syscall
Approccio di interfaccia all'I/O asincrono.
Vederehttp://www.xmailserver.org/guasi-lib.html>.

rdma Il motore di I/O RDMA supporta entrambe le semantiche di memoria RDMA
(RDMA_WRITE/RDMA_READ) e semantica del canale (Send/Recv) per il
Protocolli InfiniBand, RoCE e iWARP.

esterno
Carica un file oggetto del motore di I/O esterno. Aggiungi il nome del file del motore
come `:percorso motore'.

fallocia
Motore IO che esegue chiamate fallocate native di Linux regolari a
simula il trasferimento dei dati come fio ioengine
DDIR_READ fallocate(,mode = FALLOC_FL_KEEP_SIZE,)
DIR_WRITE fallocate(,mode = 0)
DDIR_TRIM fallocate(,mode =
FALLOC_FL_KEEP_SIZE|FALLOC_FL_PUNCH_HOLE)

e4defrag
Motore IO che esegue normali ioctls EXT4_IOC_MOVE_EXT per simulare
richiesta di attività di deframmentazione all'evento DDIR_WRITE

RBD Motore IO che supporta l'accesso diretto a Ceph Rados Block Devices (RBD)
tramite librbd senza la necessità di utilizzare il driver rbd del kernel. Questo
ioengine definisce le opzioni specifiche del motore.

gfapi Utilizzo dell'interfaccia di sincronizzazione libgfapi di Glusterfs per l'accesso diretto a Glusterfs
volumi senza dover passare attraverso FUSE. Questo ioengine definisce
opzioni specifiche del motore.

gfapi_async
Utilizzo dell'interfaccia asincrona libgfapi di Glusterfs per l'accesso diretto a
Glusterfs volumi senza dover passare attraverso FUSE. Questo motore
definisce le opzioni specifiche del motore.

libhdfs
Leggere e scrivere tramite Hadoop (HDFS). Il Nome del file l'opzione è usata per
specificare host, porta del nome-nodo hdfs a cui connettersi. questo motore
interpreta gli offset in modo leggermente diverso. In HDFS, i file una volta creati
non può essere modificato. Quindi le scritture casuali non sono possibili. Imitare
questo, il motore libhdfs si aspetta che vengano creati un sacco di piccoli file
HDFS e il motore sceglierà casualmente un file da quei file in base
sull'offset generato dal backend fio. (vedi il file di lavoro di esempio per
creare tali file, utilizzare l'opzione rw=write). Si prega di notare, potresti volere
per impostare le variabili di ambiente necessarie per lavorare con hdfs/libhdfs
propriamente.

MTD Leggere, scrivere e cancellare un dispositivo a caratteri MTD (ad es. /dev/mtd0).
Gli scarti vengono trattati come cancellazioni. A seconda del dispositivo sottostante
tipo, l'I/O potrebbe dover seguire un certo schema, ad esempio su NAND,
scrivere in sequenza per cancellare i blocchi e scartare prima
sovrascrittura. La modalità writetrim funziona bene per questo vincolo.

ioprofondità=int
Numero di unità I/O da mantenere in volo rispetto al file. Nota che aumentando
iodepth oltre 1 non influenzerà i ioengine sincroni (eccetto per piccoli degress
quando verifica_async è in uso). Anche i motori asincroni possono imporre restrizioni del sistema operativo causando
la profondità desiderata da non raggiungere. Questo può accadere su Linux quando si usa libaio
e non impostazione dirette=1, poiché l'IO bufferizzato non è asincrono su quel sistema operativo. Tenere d'occhio
la distribuzione della profondità IO nell'output fio per verificare che la profondità raggiunta sia uguale
previsto. Predefinito: 1.

ioprofondità_batch=int
Numero di I/O da inviare contemporaneamente. Predefinito: ioprofondità.

ioprofondità_batch_completa=int
Questo definisce quanti pezzi di I/O recuperare contemporaneamente. Il valore predefinito è 1 che
significa che chiederemo un minimo di 1 IO nel processo di recupero dal
nocciolo. Il recupero dell'IO andrà avanti finché non raggiungiamo il limite fissato da ioprofondità_bassa. Se
questa variabile è impostata su 0, quindi fio controllerà sempre gli eventi completati prima
accodare più IO. Ciò aiuta a ridurre la latenza IO, al costo di un maggiore sistema di recupero
chiamate.

ioprofondità_bassa=int
Filigrana bassa che indica quando ricominciare a riempire la coda. Predefinito: ioprofondità.

io_submit_mode=str
Questa opzione controlla come fio invia l'IO al motore IO. L'impostazione predefinita è
inline, il che significa che i thread del processo fio inviano e raccolgono IO direttamente. Se impostato
a scaricare, i thread di lavoro scaricheranno l'invio IO a un pool dedicato di IO
fili. Ciò richiede un po' di coordinamento e quindi ha un po' di sovraccarico in più,
soprattutto per IO con profondità di coda inferiore dove può aumentare le latenze. Il vantaggio è
che fio può gestire i tassi di invio indipendentemente dai tassi di completamento del dispositivo.
Ciò evita la segnalazione distorta della latenza se l'IO torna sul lato del dispositivo (il
problema di omissione coordinata).

dirette=bool
Se true, usa I/O senza buffer (in genere O_DIRECT). Predefinito: falso.

atomico=bool
Se il valore è vero, prova a utilizzare l'I/O diretto atomico. Le scritture atomiche sono garantite per
essere stabile una volta riconosciuto dal sistema operativo. Solo Linux supporta O_ATOMIC
al momento.

tamponato=bool
Se true, usa l'I/O bufferizzato. Questo è l'opposto di dirette parametro. Predefinito:
vero.

offset=int
Offset nel file per avviare l'I/O. I dati prima dell'offset non verranno toccati.

offset_incremento=int
Se viene fornito, l'offset reale diventa offset + offset_increment *
thread_number, dove il numero del thread è un contatore che inizia da 0 ed è
incrementato per ogni sotto-lavoro (cioè quando è specificata l'opzione numjobs). Questa opzione
è utile se ci sono diversi lavori che devono operare su un file in
segmenti paralleli disgiunti, con spaziatura uniforme tra i punti di partenza.

numero_ios=int
Fio normalmente eseguirà IO fino a quando non avrà esaurito la dimensione della regione impostata da
Taglia, o se esaurisce il tempo assegnato (o si verifica una condizione di errore). Con questo
impostazione, l'intervallo/dimensione può essere impostato indipendentemente dal numero di I/O da eseguire.
Quando fio raggiunge questo numero, uscirà normalmente e riporterà lo stato. Notare che
questo non estende la quantità di IO che verrà eseguita, fermerà fio solo se
questa condizione è soddisfatta prima di altri criteri di fine lavoro.

fsync=int
Quanti I/O eseguire prima di emettere un fsync(2) di dati sporchi. Se 0, no
sincronizzazione. Predefinito: 0.

fdatasync=int
Come fsync, ma usa fdatasync(2) invece di sincronizzare solo le parti di dati del file.
Predefinito: 0.

barriera_scrittura=int
Rendi ogni Nth scrivere una scrittura di barriera.

intervallo_file_sincronizzazione=str:int
Usa il intervallo_file_sincronizzazione(2) per ogni val numero di operazioni di scrittura. Fio seguirà
serie di scritture avvenute dall'ultimo intervallo_file_sincronizzazione(2) chiamata. str can
essere attualmente uno o più di:

attendere_prima
SYNC_FILE_RANGE_WAIT_BEFORE

scrivere SYNC_FILE_RANGE_WRITE

aspetta_dopo
SYNC_FILE_RANGE_WRITE

Quindi, se esegui sync_file_range=wait_before,write:8, fio userebbe
SYNC_FILE_RANGE_WAIT_BEFORE | SYNC_FILE_RANGE_WRITE per ogni 8 scritture. Vedi anche
, il intervallo_file_sincronizzazione(2) pagina man. Questa opzione è specifica per Linux.

sovrascrivere=bool
Se scrivi, imposta prima il file e sovrascrivi. Predefinito: falso.

end_fsync=bool
Sincronizzare il contenuto del file quando una fase di scrittura è stata completata. Predefinito: falso.

fsync_on_close=bool
Se true, sincronizza il contenuto del file alla chiusura. Questo differisce da end_fsync in questo sarà
succedere ad ogni chiusura, non solo alla fine del lavoro. Predefinito: falso.

rwmixread=int
Percentuale di un carico di lavoro misto che dovrebbe essere letto. Valore predefinito: 50.

rwmixwrite=int
Percentuale di un carico di lavoro misto che dovrebbe essere scritto. Se rwmixread e rwmixwrite
sono dati e non sommano al 100%, l'ultimo dei due prevale sul primo. Questo
può interferire con una determinata impostazione della velocità, se a fio viene chiesto di limitare le letture o le scritture
ad un certo tasso. In tal caso, la distribuzione potrebbe essere distorta.
Predefinito: 50.

distribuzione_casuale=str: galleggiante
Per impostazione predefinita, fio utilizzerà una distribuzione casuale completamente uniforme quando richiesto
eseguire IO casuale. A volte è utile distorcere la distribuzione in modo specifico
modi, assicurando che alcune parti dei dati siano più calde di altre. Fio include
i seguenti modelli di distribuzione:

con Distribuzione casuale uniforme

zipf Distribuzione Zipf

Pareto Distribuzione paretiana

Quando si utilizza una distribuzione zipf o pareto, è necessario anche un valore di input per
definire il modello di accesso. Per zipf, questo è zipf theta. Per Pareto, è il
potere di Pareto. Fio include un programma di test, genzipf, che può essere utilizzato per visualizzare cosa
i valori di input forniti produrranno in termini di percentuali di successo. Se volessi usare zipf
con un theta di 1.2, useresti random_distribution=zipf:1.2 come opzione. Se un
viene utilizzato un modello non uniforme, fio disabiliterà l'uso della mappa casuale.

percentuale_casuale=int
Per un carico di lavoro casuale, imposta quanto grande dovrebbe essere una percentuale casuale. Questa impostazione predefinita è
100%, nel qual caso il carico di lavoro è completamente casuale. Può essere impostato da qualsiasi luogo da
Da 0 a 100. Impostandolo su 0, il carico di lavoro sarà completamente sequenziale. È possibile
per impostare valori diversi per letture, scritture e trim. Per farlo, usa semplicemente una virgola
elenco separato. Vedere misura del blocco.

mappa del nord
Normalmente filo coprirà ogni blocco del file quando si esegue l'I/O casuale. Se questo
parametro è dato, verrà scelto un nuovo offset senza guardare gli I/O passati
storia. Questo parametro si esclude a vicenda con verificare.

softrandommap=bool
See mappa del nord. Se fio viene eseguito con la mappa dei blocchi casuali abilitata e non riesce
allocare la mappa, se questa opzione è impostata continuerà senza un blocco casuale
carta geografica. Poiché la copertura non sarà completa come con le mappe casuali, questa opzione è
disabilitato per impostazione predefinita.

generatore_casuale=str
Fio supporta i seguenti motori per la generazione di offset IO per IO casuale:

tausworth
Forte generatore di numeri casuali a 2^88 cicli

lfsr Generatore di registro a scorrimento con feedback lineare

Tausworthe64
Potente generatore di numeri casuali a 64 bit 2^258 cicli

Tausworthe è un potente generatore di numeri casuali, ma richiede il monitoraggio
, il
side se vogliamo assicurarci che i blocchi vengano letti o scritti solo una volta. LFSR
garantisce che non generiamo mai lo stesso offset due volte, ed è anche inferiore
computazionalmente costoso. Tuttavia, non è un vero generatore casuale, anche se per IO
scopi è in genere abbastanza buono. LFSR funziona solo con dimensioni di blocco singolo, non
con carichi di lavoro che utilizzano più dimensioni di blocco. Se utilizzato con un tale carico di lavoro, fio può
leggere o scrivere alcuni blocchi più volte.

bello=int
Esegui il lavoro con un buon valore dato. Vedere bello(2).

prio=int
Impostare il valore di priorità I/O di questo lavoro tra 0 (più alto) e 7 (più basso). Vedere
ionico(1).

priclasse=int
Imposta la classe di priorità I/O. Vedere ionico(1).

tempo di riflessione=int
Blocca il lavoro per un dato numero di microsecondi tra l'emissione di I/O.

thinktime_spin=int
Fai finta di passare il tempo della CPU per un dato numero di microsecondi, dormendo per il resto
il tempo specificato da tempo di riflessione. Valido solo se tempo di riflessione è impostato.

thinktime_blocks=int
Valido solo se è impostato thinktime: controlla quanti blocchi emettere, prima di aspettare
tempo di riflessione microsecondi. Se non è impostato, il valore predefinito è 1 che farà attendere fio
tempo di riflessione microsecondi dopo ogni blocco. Questo rende efficacemente qualsiasi profondità di coda
impostazione ridondante, poiché non verrà messo in coda più di 1 IO prima di dover
completarlo e fare il nostro tempo di riflessione. In altre parole, questa impostazione limita efficacemente il
profondità della coda se quest'ultima è maggiore. Predefinito: 1.

tasso=int
Limita la larghezza di banda utilizzata da questo lavoro. Il numero è in byte/sec, il normale suffisso
si applicano le regole. Puoi usare tasso=500k per limitare le letture e le scritture a 500k ciascuna, o tu
può specificare lettura e scrittura separatamente. Usando tasso=1m,500k limiterebbe le letture a
1 MB/sec e scrive a 500 KB/sec. È possibile limitare solo le letture o le scritture con
tasso=,500k o tasso=500k,. Il primo limiterà solo le scritture (a 500 KB/sec), il
quest'ultimo limiterà solo le letture.

tasso min=int
Dire filo fare tutto il possibile per mantenere almeno la larghezza di banda data. fallendo
soddisfare questo requisito farà terminare il lavoro. Lo stesso formato di tasso is
utilizzato per la separazione tra lettura e scrittura.

rate_iops=int
Limita la larghezza di banda a questo numero di IOPS. Fondamentalmente lo stesso del tasso, solo
specificato indipendentemente dalla larghezza di banda. Lo stesso formato di tasso è usato per leggere vs
scrivere separazione. Se misura del blocco è un intervallo, la dimensione del blocco più piccola viene utilizzata come
metrico.

velocità_iops_min=int
Se questa velocità di I/O non viene soddisfatta, il lavoro verrà terminato. Lo stesso formato di tasso viene usato
per la separazione tra lettura e scrittura.

ciclo di velocità=int
Larghezza di banda media per tasso e tasso min oltre questo numero di millisecondi. Predefinito:
1000ms.

target_latenza=int
Se impostato, fio tenterà di trovare il punto di massima prestazione che il dato carico di lavoro
verrà eseguito a mantenendo una latenza al di sotto di questo target. I valori sono dati in
microsecondi. Vedere finestra_latenza e latenza_percentile.

finestra_latenza=int
Usato con target_latenza per specificare la finestra di esempio in cui viene eseguito il lavoro
variando le profondità della coda per testare le prestazioni. Il valore è espresso in microsecondi.

latenza_percentile=galleggiante
La percentuale di IO che devono rientrare nei criteri specificati da
target_latenza e finestra_latenza. Se non è impostato, il valore predefinito è 100.0, il che significa che
tutti gli I/O devono essere uguali o inferiori al valore impostato da target_latenza.

max_latenza=int
Se impostato, fio uscirà dal lavoro se supera questa latenza massima. Uscirà con
un errore ETIME.

cpumask=int
Imposta l'affinità della CPU per questo lavoro. int è una maschera di bit delle CPU consentite su cui il lavoro può essere eseguito.
See sched_setaffinity(2).

cpus_consentito=str
Uguale a cpumask, ma consente un elenco delimitato da virgole di numeri di CPU.

cpus_allowed_policy=str
Imposta la politica di come fio distribuisce le CPU specificate da cpus_consentito or
cpumask. Sono supportati due criteri:

condiviso Tutti i lavori condivideranno il set di CPU specificato.

dividere Ogni lavoro riceverà una CPU univoca dal set di CPU.

condiviso è il comportamento predefinito, se l'opzione non è specificata. Se dividere is
specificato, allora fio assegnerà una cpu per lavoro. Se non vengono fornite abbastanza CPU per
i lavori elencati, quindi fio eseguirà il round robin delle CPU nel set.

numa_cpu_nodes=str
Imposta questo lavoro in esecuzione sulle CPU dei nodi NUMA specificati. Gli argomenti consentono la virgola
elenco delimitato di numeri di CPU, intervalli AB o "tutti".

numa_mem_policy=str
Imposta il criterio di memoria di questo lavoro e i nodi NUMA corrispondenti. Formato degli argomenti:

[: ]

modo è uno dei seguenti criteri di memoria:

predefinito preferire, legamento, intercalare, locale

Per difetto e locale politica di memoria, no lista dei nodi is
doveva essere specificato. Per preferire, è consentito un solo nodo. Per legare e
intercalare, lista dei nodi consente un elenco delimitato da virgole di numeri, intervalli AB o "tutti".

partenza ritardata=arancione
Ritarda l'avvio del lavoro per il numero di secondi specificato. Supporta tutti i suffissi temporali
per consentire la specifica di ore, minuti, secondi e millisecondi - i secondi sono
l'impostazione predefinita se viene omessa un'unità. Può essere dato come un intervallo che causa ogni thread
scegliere a caso fuori dalla gamma.

runtime=int
Termina l'elaborazione dopo il numero di secondi specificato.

basato sul tempo
Se dato, corri per il tempo specificato runtime durata anche se i file sono completamente
letto o scritto. Lo stesso carico di lavoro verrà ripetuto tante volte quanto runtime
permette.

tempo_rampa=int
Se impostato, fio eseguirà il carico di lavoro specificato per questo periodo di tempo prima della registrazione
qualsiasi numero di prestazioni. Utile per lasciare che le prestazioni si stabilizzino prima della registrazione
risultati, riducendo così al minimo il tempo di esecuzione necessario per risultati stabili. Nota che il
tempo_rampa è considerato lead in time per un lavoro, quindi aumenterà il totale
runtime se viene specificato un timeout o un runtime speciale.

infirmare=bool
Invalidare la cache del buffer per il file prima di avviare l'I/O. Predefinito: vero.

sync=bool
Utilizzare l'I/O sincrono per le scritture bufferizzate. Per la maggior parte dei motori I/O, questo
significa usare O_SYNC. Predefinito: falso.

iomemo=str, mem=str
Metodo di allocazione per il buffer dell'unità di I/O. I valori consentiti sono:

malloc Alloca la memoria con malloc(3).

shm Usa buffer di memoria condivisa allocati tramite merda(2).

shhmuge
Uguale a shm, ma usa pagine enormi come supporto.

mmap Usa il mmap(2) per l'assegnazione. Utilizza la memoria anonima a meno che non sia un nome di file
è data dopo l'opzione nel formato `:filetto'.

mmafugo
Uguale a mmap, ma usa file enormi come supporto.

La quantità di memoria allocata è la massima consentita misura del blocco per il lavoro
moltiplicato ioprofondità. For shhmuge or mmafugo per funzionare, il sistema deve avere libero
enormi pagine allocate. mmafugo ha anche bisogno di avere hugetlbfs montato, e filetto devono obbligatoriamente:
punto lì. Almeno su Linux, le pagine enormi devono essere allocate manualmente. Vedere
/proc/sys/vm/nr_hugehages e la documentazione per questo. Normalmente hai solo bisogno di
echo un numero appropriato, ad esempio echo 8 assicurerà che il sistema operativo abbia 8 pagine enormi
pronto per l'uso.

iomem_align=int, mem_align=int
Questo indica l'allineamento della memoria dei buffer di memoria IO. Nota che il dato
l'allineamento viene applicato al primo buffer dell'unità IO, se si utilizza ioprofondità l'allineamento di
i seguenti buffer sono dati da bs Usato. In altre parole, se si usa a bs che
è un multiplo della dimensione della pagina nel sistema, tutti i buffer saranno allineati a questo
valore. Se si utilizza a bs che non è allineato alla pagina, l'allineamento del successivo IO
buffer di memoria è la somma di iomem_align e bs Usato.

enormi dimensioni della pagina=int
Definisce le dimensioni di una pagina enorme. Deve essere almeno uguale all'impostazione di sistema.
Dovrebbe essere un multiplo di 1 MB. Predefinito: 4 MB.

uscita tutto
Termina tutti i lavori quando uno finisce. Predefinito: attendere il completamento di ogni lavoro.

bavgtime=int
Calcoli della larghezza di banda media nel tempo specificato in millisecondi. Predefinito:
500ms.

iopsavgtime=int
Calcoli IOPS medi nel tempo specificato in millisecondi. Predefinito: 500 ms.

creare_serializzare=bool
Se true, serializza la creazione del file per i lavori. Predefinito: vero.

create_fsync=bool
fsync(2) file di dati dopo la creazione. Predefinito: vero.

crea_su_aperto=bool
Se true, i file non vengono creati finché non vengono aperti per l'IO dal lavoro.

creare_solo=bool
Se true, fio eseguirà solo la fase di configurazione del lavoro. Se è necessario disporre i file
o aggiornato su disco, solo questo verrà fatto. Il contenuto del lavoro effettivo non lo è
eseguito.

consentire_file_creare=bool
Se true, a fio è consentito creare file come parte del suo carico di lavoro. Questo è il
comportamento predefinito. Se questa opzione è falsa, fio verrà visualizzato un errore se i file sono
esigenze da utilizzare non esistono già. Predefinito: vero.

allow_mount_write=bool
Se questo non è impostato, fio interromperà i lavori che sono distruttivi (ad esempio che scrivono) su what
sembra essere un dispositivo montato o una partizione. Questo dovrebbe aiutare a catturare la creazione
test inavvertitamente distruttivi, senza rendersi conto che il test distruggerà i dati su
il file system montato. Predefinito: falso.

pre_leggere=bool
Se viene fornito, i file verranno pre-letti in memoria prima di avviare il dato IO
operazione. Questo cancellerà anche il infirmare bandiera, poiché è inutile pre-
leggere e quindi rilasciare la cache. Funzionerà solo per i motori IO che sono ricercabili,
poiché consentono di leggere gli stessi dati più volte. Quindi non funzionerà su
ad es. rete o IO di giunzione.

scollegare=bool
Al termine, scollega i file di lavoro. Predefinito: falso.

loops=int
Specifica il numero di iterazioni (esecuzioni dello stesso carico di lavoro) di questo lavoro.
Predefinito: 1.

verifica_solo=bool
Non eseguire il carico di lavoro specificato, verifica solo che i dati corrispondano ancora a quelli precedenti
invocazione di questo carico di lavoro. Questa opzione consente di controllare i dati più volte a
una data successiva senza sovrascriverla. Questa opzione ha senso solo per i carichi di lavoro
che scrivono dati e non supportano i carichi di lavoro con il basato sul tempo set di opzioni.

fare_verificare=bool
Eseguire la fase di verifica dopo una fase di scrittura. Valido solo se verificare è impostato. Predefinito:
vero.

verificare=str
Metodo di verifica del contenuto del file dopo ogni iterazione del lavoro. Ogni
il metodo di verifica implica anche la verifica dell'intestazione speciale, che è scritta
all'inizio di ogni blocco. Questa intestazione include anche meta informazioni, come
offset del blocco, numero di blocco, timestamp quando il blocco è stato scritto, ecc.
verificare=str può essere combinato con verificare_pattern=opzione str. I valori ammessi sono:

md5 crc16 crc32 crc32c crc32c-intel crc64 crc7 sha256 sha512 sha1 xshash
Memorizza il checksum appropriato nell'intestazione di ogni blocco. crc32c-intel
è guidato da SSE4.2 con accelerazione hardware, ritorna al normale crc32c
se non supportato dal sistema.

arrivo Questa opzione è deprecata, poiché ora le meta informazioni sono incluse in
l'intestazione di verifica generica e la meta verifica si verificano per impostazione predefinita.
Per informazioni dettagliate vedere la descrizione del verificare=str
collocamento. Questa opzione viene mantenuta per motivi di compatibilità con il vecchio
configurazioni. Non usarlo.

modello
Verifica uno schema rigoroso. Normalmente fio include un'intestazione con alcuni
informazioni di base e checksum, ma se questa opzione è impostata, solo
il modello specifico impostato con verificare_pattern è verificato.

nullo Fai finta di verificare. Utilizzato per testare gli interni.

Questa opzione può essere utilizzata per ripetuti test di burn-in di un sistema per assicurarsi che
anche i dati scritti vengono riletti correttamente. Se la direzione dei dati fornita è una lettura
o lettura casuale, fio presumerà di dover verificare un file scritto in precedenza. Se
la direzione dei dati include qualsiasi forma di scrittura, la verifica sarà del nuovo
dati scritti.

verificaresort=bool
Se vero, i blocchi di verifica scritti vengono ordinati se filo ritiene che sia più veloce leggerli
indietro in modo ordinato. Predefinito: vero.

verificasort_nr=int
Precarica e ordina i blocchi di verifica per un carico di lavoro di lettura.

verifica_offset=int
Scambia l'intestazione di verifica con i dati da qualche altra parte nel blocco prima di scrivere.
Viene scambiato indietro prima della verifica.

intervallo_verifica=int
Scrivi l'intestazione di verifica per questo numero di byte, che dovrebbe dividere
misura del blocco. Predefinito: misura del blocco.

verificare_pattern=str
Se impostato, fio riempirà i buffer io con questo modello. Fio si riempie di default
con byte totalmente casuali, ma a volte è interessante riempire con un noto
pattern per scopi di verifica io. A seconda della larghezza del motivo, fio
riempirà 1/2/3/4 byte del buffer alla volta (puòessere un decimale o un
numero esadecimale). Il modello_verifica se maggiore di una quantità a 32 bit deve essere un esadecimale
numero che inizia con "0x" o "0X". Usa con verificare=str. Anche,
verificare_pattern supporta il formato %o, il che significa che per ogni blocco l'offset sarà
scritto e poi verificato di nuovo, ad esempio:
verificare_pattern=%o
Oppure usa la combinazione di tutto:

verificare_pattern=0xff%o"abcd"-21

verifica_fatale=bool
Se true, esci dal lavoro al primo errore di verifica osservato. Predefinito: falso.

verifica_dump=bool
Se impostato, scarica il contenuto sia del blocco dati originale che del blocco dati
leggere il disco in file. Ciò consente un'analisi successiva per verificare che tipo di
si è verificata la corruzione dei dati. Disattivato per impostazione predefinita.

verifica_asincrona=int
Fio normalmente verificherà IO in linea dal thread di invio. Questa opzione richiede un
intero che descrive quanti thread offload asincroni creare per la verifica IO
invece, facendo sì che fio scarichi il compito di verificare i contenuti IO su uno o più
fili separati. Se si utilizza questa opzione di offload, anche i motori di IO di sincronizzazione possono trarne vantaggio
dall'uso di an ioprofondità un'impostazione maggiore di 1, in quanto consente loro di avere IO in volo
mentre le verifiche sono in esecuzione.

verifica_async_cpus=str
Dire a fio di impostare l'affinità CPU data sui thread di verifica IO asincroni. Vedere
cpus_consentito per il formato utilizzato.

verifica_arretrato=int
Fio verificherà normalmente il contenuto scritto di un lavoro che utilizza la verifica una volta
quel lavoro è stato completato. In altre parole, tutto è scritto poi tutto è
riletto e verificato. Potresti voler verificare continuamente invece per una varietà di
motivi. Fio memorizza i metadati associati a un blocco IO in memoria, quindi per
grandi carichi di lavoro di verifica, un bel po' di memoria verrebbe utilizzata per contenere questo meta
dati. Se questa opzione è abilitata, fio scriverà solo N blocchi prima di verificare
questi blocchi.

verificare_backlog_batch=int
Controlla quanti blocchi fio verificherà se configure_backlog. Se non impostato, will
predefinito al valore di verifica_arretrato (il che significa che l'intera coda viene letta e
verificato). Se verificare_backlog_batch è meno di verifica_arretrato quindi non tutti i blocchi
sarà verificato, se verificare_backlog_batch è più grande di verifica_arretrato, alcuni
blocchi verranno verificati più di una volta.

trim_percentuale=int
Numero di blocchi di verifica da scartare/tagliare.

trim_verify_zero=bool
Verificare che i blocchi tagliati/scartati vengano restituiti come zero.

trim_arretrato=int
Trim dopo che questo numero di blocchi è stato scritto.

trim_backlog_batch=int
Taglia questo numero di blocchi IO.

sperimentale_verifica=bool
Abilita la verifica sperimentale.

verifica_stato_save=bool
Quando un lavoro termina durante la fase di scrittura di un carico di lavoro di verifica, salva il suo attuale
stato. Ciò consente a fio di riprodurre fino a quel momento, se lo stato di verifica è caricato
per la fase di verifica lettura.

verifica_stato_carico=bool
Se è stato utilizzato un trigger di terminazione di verifica, fio memorizza lo stato di scrittura corrente di
ogni filo. Questo può essere usato al momento della verifica in modo che fio sappia quanto lontano
dovrebbe verificare. Senza queste informazioni, fio eseguirà un pass di verifica completo,
in base alle impostazioni nel file di lavoro utilizzato.

ostacolare , attendi_precedente
Attendere la chiusura dei lavori precedenti nel file di lavoro prima di avviare questo.
ostacolare implica nuovo gruppo.

nuovo gruppo
Avvia un nuovo gruppo di rapporti. In caso contrario, tutti i lavori in un file faranno parte del
stesso gruppo di segnalazione, a meno che non sia separato da un muro di pietra.

num lavori=int
Numero di cloni (processi/thread che eseguono lo stesso carico di lavoro) di questo lavoro.
Predefinito: 1.

report_di gruppo
Se impostato, visualizza i rapporti per gruppo anziché per lavoro quando num lavori è specificato.

filo Usa thread creati con pthread_create(3) invece di processi creati con
forcella(2).

dimensione della zona=int
Divide il file in zone della dimensione specificata in byte. Vedere salto di zona.

intervallo di zona=int
Indica la dimensione di una zona IO. Vedere salto di zona.

salto di zona=int
Salta il numero di byte specificato quando dimensione della zona sono stati letti byte di dati.

write_ilog=str
Scrivere i modelli di I/O emessi nel file specificato. Specifica un file separato per
ogni lavoro, altrimenti gli iologs verranno interrotti e il file potrebbe essere danneggiato.

read_ilog=str
Riproduce i pattern di I/O contenuti nel file specificato generato da write_ilog,
o potrebbe essere un traccia nera file binario.

replay_no_stallo=int
Durante la riproduzione di pattern I/O utilizzando read_ilog il comportamento predefinito tenta di
rispettare le informazioni sui tempi tra gli I/O. Abilitare replay_no_stallo fa sì che gli I/O
essere riprodotti il ​​più velocemente possibile pur rispettando l'ordine.

riproduci_reindirizzamento=str
Durante la riproduzione di pattern I/O utilizzando read_ilog il comportamento predefinito è riprodurre il
IOPS sul dispositivo principale/secondario da cui è stato registrato ogni IOP. Collocamento
riproduci_reindirizzamento fa sì che tutti gli IOPS vengano riprodotti sul singolo dispositivo specificato
indipendentemente dal dispositivo da cui è stato registrato.

riproduci_align=int
Forza l'allineamento degli offset e delle lunghezze di I/O in una traccia a questo valore di potenza 2.

riproduzione_scala=int
Ridimensiona gli offset di settore verso il basso di questo fattore durante la riproduzione delle tracce.

per_job_logs=bool
Se impostato, genera log bw/clat/iops con nomi di file privati ​​per file. Altrimenti
set, i lavori con nomi identici condivideranno il nome del file di registro. Predefinito: vero.

write_bw_log=str
Se fornito, scrivere un registro della larghezza di banda dei lavori in questo file di lavoro. Può essere usato per conservare
dati della larghezza di banda dei lavori nel corso della loro vita. L'incluso
Lo script fio_generate_plots usa gnuplot per trasformare questi file di testo in simpatici grafici.
See write_lat_log per il comportamento di un dato nome di file. Per questa opzione, il suffisso è
_bw.x.log, dove x è l'indice del lavoro (1..N, dove N è il numero di lavori).
If per_job_logs è false, il nome del file non includerà l'indice del lavoro.

write_lat_log=str
Uguale a write_bw_log, ma scrive le latenze di completamento I/O. Se non viene fornito alcun nome di file
con questa opzione, viene utilizzato il nome file predefinito di "jobname_type.x.log", dove x è
l'indice del lavoro (1..N, dove N è il numero di lavori). Anche se il nome del file è
dato, fio aggiungerà comunque il tipo di log. Se per_job_logs è falso, allora il
nome file non includerà l'indice del lavoro.

write_iops_log=str
Uguale a write_bw_log, ma scrive IOPS. Se non viene fornito alcun nome di file con questa opzione,
viene utilizzato il nome file predefinito di "jobname_type.x.log", dove x è l'indice del
lavoro (1..N, dove N è il numero di lavori). Anche se viene fornito il nome del file, fio lo farà
aggiungere ancora il tipo di registro. Se per_job_logs è falso, allora il nome del file non lo farà
includere l'indice del lavoro.

log_avg_msec=int
Per impostazione predefinita, fio registrerà una voce nel registro iops, latenza o bw per ogni IO che
completa. Quando si scrive nel registro del disco, questo può diventare rapidamente molto grande
dimensione. L'impostazione di questa opzione fa in modo che fio faccia la media di ciascuna voce di registro su quella specificata
periodo di tempo, riducendo la risoluzione del log. Il valore predefinito è 0.

log_offset=bool
Se questo è impostato, le opzioni iolog includeranno l'offset di byte per la voce IO come
così come gli altri valori dei dati.

log_compressione=int
Se questo è impostato, fio comprimerà i registri IO mentre procede, per mantenere la memoria
impronta inferiore. Quando un log raggiunge la dimensione specificata, quel pezzo viene rimosso e
compresso in sottofondo. Dato che i log IO sono abbastanza altamente comprimibili,
questo produce un buon risparmio di memoria per corse più lunghe. Il rovescio della medaglia è che
la compressione consumerà alcuni cicli della CPU in background, quindi potrebbe influire sull'esecuzione.
Questo, tuttavia, è vero anche se il logging finisce per consumare la maggior parte del sistema
memoria. Quindi scegli il tuo veleno. I log di I/O vengono salvati normalmente alla fine di un'esecuzione, da
decomprimendo i blocchi e memorizzandoli nel file di registro specificato. Questa caratteristica
dipende dalla disponibilità di zlib.

log_store_compresso=bool
Se impostato, e ceppoanche _compression è impostato, fio memorizzerà i file di registro in a
formato compresso. Possono essere decompressi con fio, utilizzando il --gonfia-log
parametro della riga di comando. I file verranno archiviati con a .fz suffisso.

block_error_percentiles=bool
Se impostato, registra gli errori nelle unità di dimensioni del blocco di trim da scritture e trim e output a
istogramma di quanti tagli sono stati necessari per ottenere errori e che tipo di errore era
incontrato.

disabilitare_lat=bool
Disabilita le misurazioni dei numeri di latenza totale. Utile solo per ridurre il
numero di chiamate a gettimeofday(2), poiché ciò influisce sulle prestazioni a livelli davvero elevati
Tariffe IOPS. Nota che per eliminare davvero una grande quantità di queste chiamate, questo
L'opzione deve essere utilizzata anche con disable_slat e disable_bw.

disabili_clat=bool
Disabilita le misurazioni dei numeri di latenza di completamento. Vedere disabilitare_lat.

disable_slat=bool
Disabilita le misurazioni dei numeri di latenza di invio. Vedere disabilitare_lat.

disable_bw_measurement=bool
Disabilita le misurazioni dei numeri di throughput/larghezza di banda. Vedere disabilitare_lat.

lock mem=int
Blocca la quantità di memoria specificata con mlock(2). Può essere utilizzato per simulare a
minore quantità di memoria. L'importo specificato è per lavoratore.

exec_prerun=str
Prima di eseguire il lavoro, eseguire il comando specificato con sistema(3).
L'output viene reindirizzato in un file chiamato nomelavoro.prerun.txt

exec_postrun=str
Uguale a exec_prerun, ma il comando viene eseguito al termine del lavoro.
L'output viene reindirizzato in un file chiamato nomelavoro.postrun.txt

ioschedule=str
Tentativo di passare il dispositivo che ospita il file allo scheduler di I/O specificato.

disk_util=bool
Genera statistiche sull'utilizzo del disco se la piattaforma lo supporta. Predefinito: vero.

sorgente dell'orologio=str
Usa la data sorgente di clock come base del tempo. Le opzioni supportate sono:

gettimeofday
gettimeofday(2)

orologio_gettime
orologio_gettime(2)

cpu Sorgente di clock della CPU interna

cpu è la sorgente di clock preferita se è affidabile, in quanto è molto veloce
(e fio è molto puntuale nelle chiamate). Fio utilizzerà automaticamente questa sorgente di clock se
è supportato e considerato affidabile sul sistema su cui è in esecuzione, a meno che
un'altra sorgente di clock è impostata in modo specifico. Per le CPU x86/x86-64, questo significa supportare
Invariante TSC.

gtod_ridurre=bool
Abilita tutti i gettimeofday(2) opzioni di riduzione (disable_clat, disable_slat,
disabilita_bw) e in più riduci leggermente la precisione del timeout per ridurre davvero il
gettimeofday(2) numero di chiamate. Con questa opzione abilitata, eseguiamo solo lo 0.4% circa del
gtod() che avremmo fatto se fosse stato abilitato il mantenimento del tempo.

gtod_cpu=int
A volte è più economico dedicare un singolo thread di esecuzione solo per ottenere il
ora attuale. Fio (e database, per esempio) sono molto intensivi
gettimeofday(2) chiamate. Con questa opzione, puoi mettere da parte una CPU per farlo
nient'altro che registrare l'ora corrente in una posizione di memoria condivisa. poi l'altro
i thread/processi che eseguono carichi di lavoro IO devono solo copiare quel segmento, invece di
entrando nel kernel con a gettimeofday(2) chiamata. La CPU messa da parte per fare queste cose
le chiamate a tempo saranno escluse da altri usi. Fio lo cancellerà manualmente dal
Maschera CPU di altri lavori.

ignora_errore=str
A volte vuoi ignorare alcuni errori durante il test in quel caso puoi specificare
elenco degli errori per ogni tipo di errore.
ignore_error=READ_ERR_LIST,WRITE_ERR_LIST,VERIFY_ERR_LIST
gli errori per un dato tipo di errore sono separati da ':'. L'errore può essere un simbolo ("ENOSPC",
'ENOMEM') o un numero intero.
Esempio: ignore_error=EAGAIN,ENOSPC:122 .
Questa opzione ignorerà EAGAIN da READ e ENOSPC e 122(EDQUOT) da WRITE.

dump_errore=bool
Se impostato dump ogni errore anche se non è fatale, true per impostazione predefinita. Solo se disabilitato
errore fatale verrà scaricato

tuo profilo=str
Seleziona uno specifico test delle prestazioni integrato.

cgruppo=str
Aggiungi lavoro a questo gruppo di controllo. Se non esiste, verrà creato. Il sistema
deve avere un punto di montaggio cgroup blkio montato affinché funzioni. Se il tuo sistema
non è montato, puoi farlo con:

# mount -t cgroup -o blkio nessuno /cgroup

cgroup_peso=int
Imposta il peso del cgroup su questo valore. Consulta la documentazione fornita con
il kernel, i valori consentiti sono nell'intervallo 100..1000.

cgroup_nodelete=bool
Normalmente fio cancellerà i cgroup che ha creato dopo il completamento del lavoro. a
sovrascrivere questo comportamento e lasciare cgroups in giro dopo il completamento del lavoro, set
cgroup_nodelete=1. Questo può essere utile se si desidera ispezionare vari file cgroup
dopo il completamento del lavoro. Predefinito: falso

uid=int
Invece di eseguire come l'utente invocante, imposta l'ID utente su questo valore prima del
thread/processo fa qualsiasi lavoro.

gid=int
Imposta l'ID del gruppo, vedi uid.

base_unità=int
Unità di base per la segnalazione. I valori consentiti sono:

0 Usa il rilevamento automatico (impostazione predefinita).

8 Basato su byte.

1 Basato su bit.

id_flusso=int
L'ID del flusso. Se non specificato, per impostazione predefinita è un flusso globale. Vedere flusso.

flusso=int
Peso nel controllo di flusso basato su token. Se viene utilizzato questo valore, allora c'è a flusso
contrastare che viene utilizzato per regolare la proporzione di attività tra due o più
lavori. fio tenta di mantenere questo contatore di flusso vicino allo zero. Il flusso stand di parametro
per quanto dovrebbe essere aggiunto o sottratto al contatore di flusso ad ogni iterazione di
il circuito di I/O principale. Cioè, se un lavoro ha flusso=8 e un altro lavoro ha flusso=-1, poi
ci sarà un rapporto di circa 1:8 in quanto uno funziona rispetto all'altro.

flusso_filigrana=int
Il valore massimo che il valore assoluto del contatore di flusso può raggiungere
prima che il lavoro debba attendere un valore inferiore del contatore.

flusso_sonno=int
Il periodo di tempo, in microsecondi, di attesa dopo che la filigrana di flusso è stata
superato prima di ritentare le operazioni

clat_percentili=bool
Abilita la segnalazione dei percentili delle latenze di completamento.

elenco_percentile=float_list
Sovrascrivi l'elenco predefinito di percentili per le latenze di completamento e il blocco
istogramma di errore. Ogni numero è un numero mobile nell'intervallo (0,100] e il
la lunghezza massima dell'elenco è 20. Utilizzare ':' per separare i numeri. Per esempio,
--percentile_list=99.5:99.9 farà sì che fio riporti i valori di completamento
latenza al di sotto della quale scendono rispettivamente il 99.5% e il 99.9% delle latenze osservate.

Iomotore parametri Lista
Alcuni parametri sono validi solo quando è in uso uno specifico ioengine. Questi sono usati
in modo identico ai parametri normali, con l'avvertenza che quando vengono utilizzati sulla riga di comando, essi
deve venire dopo il motore.

(cpu) cpuload=int
Tentativo di utilizzare la percentuale specificata di cicli CPU.

CPU (cpu).=int
Suddividere il carico in cicli del tempo dato. In microsecondi.

(cpu)exit_on_io_done=bool
Rileva quando i thread IO sono finiti, quindi esci.

(libero)userspace_reap
Normalmente, con il motore libaio in uso, fio utilizzerà la chiamata di sistema io_getevents
per raccogliere gli eventi appena restituiti. Con questo flag attivato, verrà letto l'anello AIO
direttamente dallo spazio utente per raccogliere eventi. La modalità di raccolta è abilitata solo quando
polling per un minimo di 0 eventi (es. quando iodepth_batch_complete=0).

(net, netsplice) hostname=str
Il nome host o l'indirizzo IP da utilizzare per l'IO basato su TCP o UDP. Se il lavoro è un TCP
listener o lettore UDP, il nome host non viene utilizzato e deve essere omesso a meno che non sia un
indirizzo multicast UDP valido.

(rete, netsplice) porta=int
La porta TCP o UDP a cui collegarsi o a cui connettersi. Se questo viene utilizzato con num lavori deporre le uova
più istanze dello stesso tipo di lavoro, questo sarà il numero di porta iniziale
poiché fio utilizzerà una gamma di porte.

(net, netsplice) interfaccia=str
L'indirizzo IP dell'interfaccia di rete utilizzata per inviare o ricevere multicast UDP
pacchetti.

(net,netsplice)ttl=int
Valore time-to-live per i pacchetti multicast UDP in uscita. Predefinito: 1

(net,netsplice) ritardo di nodo=bool
Imposta TCP_NODELAY sulle connessioni TCP.

(net,netsplice)protocollo=str, proto=str
Il protocollo di rete da utilizzare. I valori accettati sono:

tcp Protocollo di controllo della trasmissione

tcpv6 Protocollo di controllo della trasmissione V6

udp Protocollo del datagramma utente

udpv6 Protocollo datagramma utente V6

unix Socket di dominio UNIX

Quando il protocollo è TCP o UDP, è necessario indicare anche la porta e la
hostname se il lavoro è un listener TCP o un lettore UDP. Per i socket unix, il normale
dovrebbe essere utilizzata l'opzione filename e la porta non è valida.

(net, netsplice) ascolta
Per le connessioni di rete TCP, dire a fio di ascoltare piuttosto le connessioni in entrata
piuttosto che avviare una connessione in uscita. Il nome host deve essere omesso se questa opzione
viene utilizzato.

(rete,ping-pong)=bool
Normalmente uno scrittore di rete continuerà a scrivere dati e un lettore di rete
consumerà solo pacchetti. Se pingpong=1 è impostato, uno scrittore invierà il suo normale
payload al lettore, quindi attendere che il lettore invii indietro lo stesso payload.
Ciò consente a fio di misurare le latenze di rete. La presentazione e il completamento
le latenze quindi misurano il tempo locale speso per l'invio o la ricezione e il completamento
la latenza misura il tempo impiegato dall'altra estremità per ricevere e inviare indietro. Per
Il traffico multicast UDP pingpong=1 deve essere impostato solo per un singolo lettore quando
più lettori stanno ascoltando lo stesso indirizzo.

(rete,dimensione_finestra)=int
Impostare la dimensione del buffer del socket desiderata per la connessione.

(rete,signorina)=int
Imposta la dimensione massima del segmento TCP (TCP_MAXSEG).

(e4defrag, nome del donatore)=str
Il file verrà utilizzato come donatore di blocchi (scambia le estensioni tra i file)

(e4defrag, sul posto)=int
Configura la strategia di allocazione del blocco dei file del donatore
0 (predefinito): Preallocazione del file del donatore su init

1: allocare spazio immediatamente all'interno dell'evento di deframmentazione e liberare subito dopo
evento

(rbd)rbdnome=str
Specifica il nome dell'RBD.

(rbd)piscina=str
Specifica il nome del pool Ceph contenente l'RBD.

(rbd)nomecliente=str
Specifica il nome utente (senza il prefisso 'client.') utilizzato per accedere a Ceph
grappolo.

(mtd) saltacattivo=bool
Salta le operazioni contro i blocchi danneggiati noti.

USCITA

Mentre corro, filo visualizzerà lo stato dei lavori creati. Per esempio:

Discussioni: 1: [_r] [24.8% fatto] [ 13509/ 8334 kb/s] [eta 00h:01m:31s]

I caratteri nella prima serie di parentesi indicano lo stato corrente di ogni thread.
I valori possibili sono:

P Installazione ma non avviata.
C Discussione creata.
I Inizializzato, in attesa.
R Correre, eseguire letture sequenziali.
r Correre, eseguire letture casuali.
W Esecuzione, scritture sequenziali.
w Esecuzione, scritture casuali.
M In esecuzione, eseguendo letture/scritture sequenziali miste.
m In esecuzione, eseguendo letture/scritture casuali miste.
F In esecuzione, attualmente in attesa di fsync(2).
V Esecuzione, verifica dei dati scritti.
E Uscito, non raccolto dal thread principale.
- Uscito, filo raccolto.

La seconda serie di parentesi mostra la percentuale di completamento stimata del gruppo corrente.
Il terzo set mostra rispettivamente la velocità di I/O di lettura e scrittura. Infine, la corsa stimata
viene visualizzata l'ora del lavoro.

Quando filo completa (o viene interrotta da Ctrl-C), mostrerà i dati per ogni thread, ciascuno
gruppo di thread e ogni disco, in questo ordine.

Le statistiche per thread mostrano prima il numero di client dei thread, l'ID di gruppo e il codice di errore. Il
le restanti cifre sono le seguenti:

io Numero di megabyte di I/O eseguiti.

bw Velocità dati media (larghezza di banda).

nano Tempo di esecuzione dei thread.

stecca Latenza di invio minima, massima, media e deviazione standard. Questo è
il tempo impiegato per inviare l'I/O.

Clat Latenza di completamento minima, massima, media e deviazione standard. Questo
è il tempo che intercorre tra la presentazione e il completamento.

bw Larghezza di banda minima, massima, percentuale della larghezza di banda aggregata ricevuta,
media e deviazione standard.

cpu Statistiche sull'utilizzo della CPU. Include l'ora dell'utente e del sistema, il numero di contesti
switch attraversati da questo thread e il numero di errori di pagina principali e secondari.

IO profondità
Distribuzione delle profondità di I/O. Ogni profondità include tutto ciò che è inferiore a (o
uguale) ad essa, ma maggiore della profondità precedente.

IO rilasciato
Numero di richieste di lettura/scrittura emesse e numero di brevi letture/scritture
richieste.

IO latenze
Distribuzione delle latenze di completamento dell'I/O. I numeri seguono lo stesso
modello come IO profondità.

Le statistiche del gruppo mostrano:
io Numero di megabyte I/O eseguiti.
aggr Larghezza di banda aggregata dei thread nel gruppo.
min Larghezza di banda media minima una sega a filo.
max Larghezza di banda media massima una sega a filo.
menta Tempo di esecuzione più breve dei thread nel gruppo.
max Runtime più lungo dei thread nel gruppo.

Infine, le statistiche del disco vengono stampate con le letture per prime:
ios Numero di I/O eseguiti da tutti i gruppi.
unire Numero di unioni nello scheduler di I/O.
zecche Numero di tick in cui abbiamo tenuto occupato il disco.
io_coda
Tempo totale trascorso nella coda del disco.
utile Utilizzo del disco.

È anche possibile fare in modo che fio scarichi l'uscita di corrente mentre è in esecuzione, senza
terminare il lavoro. Per farlo, invia a fio il USR1 segnale.

TERSO USCITA

Se l' --minimo / --appendere-conciso vengono fornite le opzioni, i risultati verranno stampati/aggiunti
in un formato delimitato da punto e virgola adatto all'uso con script. Una descrizione del lavoro (se
fornito) segue su una nuova riga. Nota che il primo numero nella riga è la versione
numero. Se l'uscita deve essere modificata per qualche motivo, questo numero verrà incrementato
di 1 per indicare quel cambiamento. I campi sono:

conciso versione, filo versione, nome del lavoro, ID di gruppo, errore

Stato di lettura:
Totale I / O (KB), larghezza di banda (KB/s), IOPS, runtime (Signorina)

Latenza di invio:
min, max significare, Standard deviazione
Latenza di completamento:
min, max significare, Standard deviazione
Percentili di latenza di completamento (20 campi):
X percentile=usec
Latenza totale:
min, max significare, Standard deviazione
Larghezza di banda:
min, max aggregato percentuale of totale, significare, Standard deviazione

Stato di scrittura:
Totale I / O (KB), larghezza di banda (KB/s), IOPS, runtime (Signorina)

Latenza di invio:
min, max significare, Standard deviazione
Latenza di completamento:
min, max significare, Standard deviazione
Percentili di latenza di completamento (20 campi):
X percentile=usec
Latenza totale:
min, max significare, Standard deviazione
Larghezza di banda:
min, max aggregato percentuale of totale, significare, Standard deviazione

Uso della CPU:
utente, sistema, contesto interruttori, maggiore pagina difetti, minore pagina guasti

Distribuzione profondità I/O:
<=1, 2, 4, 8, 16 32 > = 64

Distribuzione latenza IO:
Microsecondi:
<=2, 4, 10 20 50 100 250 500 750 1000
Millisecondi:
<=2, 4, 10 20 50 100 250 500 750 1000 2000 > = 2000

Utilizzo del disco (1 per ogni disco utilizzato):
nome, read ios, scrivere ios, read si fonde, scrivere si fonde, read zecche, scrivere
zecche, read in coda tempo, scrivere in coda tempo, disco utilizzo percentuale

Informazioni sull'errore (dipende da continue_on_error, disattivata per impostazione predefinita):
totale # errori, prima di tutto errore codice

testo descrizione (Se purché in config - appare on nuova linea)

CLIENTE / SERVER

Normalmente eseguiresti fio come applicazione autonoma sulla macchina in cui IO
carico di lavoro dovrebbe essere generato. Tuttavia, è anche possibile eseguire il frontend e il backend
di fio separatamente. Ciò rende possibile avere un server fio in esecuzione sulle macchine
dove dovrebbe essere in esecuzione il carico di lavoro IO, controllandolo da un'altra macchina.

Per avviare il server, dovresti fare:

filo --server=argomenti

su quella macchina, dove args definisce cosa ascolta fio. Gli argomenti sono della forma
'tipo:nomehost o IP:porta'. 'type' è 'ip' (o ip4) per TCP/IP v4, 'ip6' per TCP/IP
v6, o 'sock' per un socket di dominio unix locale. 'hostname' è un nome host o un IP
indirizzo e "porta" è la porta da ascoltare (valida solo per TCP/IP, non per un socket locale).
Qualche esempio:

1) fio --server

Avvia un server fio, in ascolto su tutte le interfacce sulla porta predefinita (8765).

2) fio --server=ip:nomehost,4444

Avvia un server fio, in ascolto sull'IP appartenente al nome host e sulla porta 4444.

3) fio --server=ip6:::1,4444

Avvia un server fio, in ascolto su IPv6 localhost ::1 e sulla porta 4444.

4) fio --server=,4444

Avvia un server fio, in ascolto su tutte le interfacce sulla porta 4444.

5) fio --server=1.2.3.4

Avvia un server fio, in ascolto su IP 1.2.3.4 sulla porta predefinita.

6) fio --server=calza:/tmp/fio.sock

Avvia un server fio, in ascolto sul socket locale /tmp/fio.sock.

Quando un server è in esecuzione, puoi connetterti ad esso da un client. Il client viene eseguito con:

fio --local-args --client=server --remote-args

dove --local-args sono argomenti locali per il client in cui è in esecuzione,
'server' è la stringa di connessione e --remote-args e vengono inviati al
server. La stringa 'server' segue lo stesso formato del lato server, per
consenti stringhe IP/nome host/socket e porta. Puoi anche connetterti a più client,
per farlo potresti eseguire:

fio --client=server2 --client=server2

Se il file di lavoro si trova sul server fio, puoi dire al server di caricare un file locale
anche file. Questo viene fatto usando --remote-config:

fio --client=server --remote-config /percorso/del/file.fio

Quindi fio aprirà questo file di lavoro locale (al server) invece di esserne passato uno da
il cliente.

Se hai molti server (esempio: 100 VM/contenitori), puoi inserire un percorso di un file
contenente IP/nomi host come valore del parametro per l'opzione --client. Per esempio,
ecco un esempio di file "host.list" contenente 2 nomi host:

host1.tuo.dominio.dns
host2.tuo.dominio.dns

Il comando fio sarebbe quindi:

fio --client=host.list

In questa modalità, non è possibile inserire parametri o file di lavoro specifici del server e tutti i server
ricevere lo stesso file di lavoro.

Per abilitare fio --client viene eseguito utilizzando un filesystem condiviso da più host,
fio --client ora antepone l'indirizzo IP del server al nome del file. Ad esempio, se
fio sta usando la directory /mnt/nfs/fio e sta scrivendo il nome del file fileio.tmp, con un --client
hostfile contenente due nomi host h1 e h2 con indirizzi IP 192.168.10.120 e
192.168.10.121, quindi fio creerà due file:

/mnt/nfs/fio/192.168.10.120.fileio.tmp
/mnt/nfs/fio/192.168.10.121.fileio.tmp

AUTORI

filo è stato scritto da Jens Axboe[email protected]>, ora Jens Axboe[email protected]>.
Questa pagina man è stata scritta da Aaron Carroll[email protected]> in base alla documentazione
di Jens Axboe.

REPORTING BUG

Segnala bug al filo mailing list[email protected]>. Vedere README.

Usa fio online utilizzando i servizi onworks.net