fio - Online en la nube

PROGRAMA:

NOMBRE

fio - comprobador de E / S flexible

SINOPSIS

fio [opciones] [archivo de trabajo] ...

DESCRIPCIÓN

fio es una herramienta que generará una serie de subprocesos o procesos que realizan un tipo particular de
Acción de E / S según lo especificado por el usuario. El uso típico de fio es escribir un archivo de trabajo
coincidir con la carga de E / S que se desea simular.

CAMPUS

--depurar=tipo
Habilite el seguimiento detallado de varias acciones de fio. Puede ser 'todos' para todos los tipos o
tipos individuales separados por una coma (por ejemplo, --debug = io, archivo). 'ayuda' enumerará todo
opciones de rastreo disponibles.

--producción=nombre de archivo
Escribir salida en nombre de archivo.

--formato de salida=formato
Establezca el formato de informe en normal, breveo json.

--tiempo de ejecución=tiempo de ejecución
Limite el tiempo de ejecución a tiempo de ejecución segundos.

- registro de ancho de banda
Genere registros de ancho de banda por trabajo.

--mínimo
Imprima estadísticas en un formato conciso delimitado por punto y coma.

--append-conciso
Imprimir estadísticas en el modo seleccionado Y conciso, en formato delimitado por punto y coma.

--versión
Muestra la información de la versión y sale.

--terse-versión=versión
Configure el formato de salida de la versión concisa (versión actual 3 o versión anterior 2).

--ayuda Mostrar información de uso y salir.

--cpuclock-prueba
Realizar prueba y validación del reloj interno de la CPU

--crctest [=prueba]
Pruebe la velocidad de las funciones de suma de verificación integradas. Si no se da ningún argumento, todos
de ellos se prueban. O se puede pasar una lista separada por comas, en cuyo caso el
los dados se prueban.

--cmdayuda=comando
Imprimir información de ayuda para comando. Puede ser "todos" para todos los comandos.

--enghelp=ioengine [, comando]
Lista todos los comandos definidos por iomotoro ayuda para imprimir para comando definido por
iomotor.

--showcmd=archivo de trabajo
Convertir archivo de trabajo a un conjunto de opciones de la línea de comandos.

--eta=cuando
Especifica cuándo se debe imprimir la estimación de ETA en tiempo real. cuando puede ser uno de
`siempre ',` nunca' o `auto '.

--eta-nueva línea=equipo
Forzar una nueva línea de ETA por cada período de tiempo transcurrido.

--intervalo de estado=equipo
Informe el estado de salida completo cada período de tiempo transcurrido.

--solo lectura
Active las comprobaciones de seguridad de solo lectura, evitando cualquier intento de escritura.

--sección=AMF
Solo ejecutar sección AMF desde el archivo de trabajo. Esta opción se puede utilizar varias veces para agregar
más secciones para ejecutar.

- tamaño alloc=kb
Establezca el tamaño interno de la piscina pequeña en kb kilobytes.

- advertencias-fatal
Todas las advertencias del analizador fio son fatales, lo que hace que fio salga con un error.

--max-trabajos=nr
Establezca el número máximo permitido de trabajos (subprocesos / procesos) para admitir.

--servidor=args
Inicie un servidor backend, con args especificando qué escuchar. Ver cliente / servidor
.

- demonizar=archivo pid
Fondo de un servidor fio, escribiendo el pid en el archivo pid dado.

--cliente=fortaleza
En lugar de ejecutar los trabajos localmente, envíelos y ejecútelos en el host o conjunto de
Hospedadores. Consulte la sección cliente / servidor.

--inactivo-prof=opción
Informar la inactividad de la CPU en un sistema o en una base de percpu (opción= sistema, percpu) o unidad de ejecución
trabajo de calibración solamenteopción= calibrar).

TRABAJO ARCHIVO FORMATO

Los archivos de trabajo están en formato "ini". Consisten en una o más definiciones de trabajo, que comienzan
con un nombre de trabajo entre corchetes y se extiende al siguiente nombre de trabajo. El nombre del trabajo puede ser
cualquier cadena ASCII excepto `global ', que tiene un significado especial. Siguiendo el nombre del trabajo es
una secuencia de cero o más parámetros, uno por línea, que definen el comportamiento del trabajo.
Cualquier línea que comience con un `; ' o el carácter '#' se considera un comentario y se ignora.

If archivo de trabajo se especifica como `- ', el archivo de trabajo se leerá desde la entrada estándar.

Buscar Sección
La sección global contiene parámetros predeterminados para trabajos especificados en el archivo de trabajo. Un trabajo
solo se ve afectado por las secciones globales que residen por encima de él, y puede haber cualquier número de
secciones globales. Las definiciones de trabajo específicas pueden anular cualquier parámetro establecido en global.
.

TRABAJO PARÁMETROS

Tipos
Algunos parámetros pueden tomar argumentos de un tipo específico. En cualquier lugar donde un valor numérico sea
requerido, se puede usar una expresión aritmética, siempre que esté entre paréntesis.
Los operadores admitidos son:

adición (+)

sustracción (-)

multiplicación (*)

división (/)

módulo (%)

exponenciación (^)

Para valores de tiempo en expresiones, las unidades son microsegundos por defecto. Esto es diferente a
para valores de tiempo no en expresiones (no entre paréntesis). Los tipos utilizados son:

str Cadena: una secuencia de caracteres alfanuméricos.

int Entero SI: un número entero, posiblemente conteniendo un sufijo que denota la unidad base de
el valor. Los sufijos aceptados son 'k', 'M', 'G', 'T' y 'P', que denotan kilo
(1024), mega (1024 ^ 2), giga (1024 ^ 3), tera (1024 ^ 4) y peta (1024 ^ 5)
respectivamente. Si tiene el prefijo '0x', se supone que el valor es base 16
(hexadecimal). Un sufijo puede incluir una 'b' al final, por ejemplo, 'kb' es idéntico
a 'k'. Puede especificar un valor de base 10 utilizando 'KiB', 'MiB', 'GiB', etc.
útil para unidades de disco donde los valores se dan a menudo en valores de base 10. Especificando
'30GiB' le dará 30 * 1000 ^ 3 bytes. Al especificar las horas, el sufijo predeterminado
el significado cambia, aún denotando la unidad base del valor, pero sufijos aceptados
son 'D' (días), 'H' (horas), 'M' (minutos), 'S' Segundos, 'ms' (o mseg) mili
segundos, 'us' (o 'usec') microsegundos. Valores de tiempo sin una unidad especificada
segundos. Los sufijos no distinguen entre mayúsculas y minúsculas.

bool Booleano: un valor verdadero o falso. '0' denota falso, '1' denota verdadero.

irango Intervalo de enteros: un intervalo de enteros especificado en el formato inferior:superior or
inferior-superior. inferior y superior puede contener un sufijo como se describe arriba. Si una opcion
permite dos conjuntos de rangos, se separan con un carácter `, 'o` /'. Para
ejemplo: '8-8k / 8M-4G'.

lista_flotante
Lista de números flotantes: una lista de números flotantes, separados por un carácter ':'.

Parámetro Lista
nombre =str
Puede usarse para anular el nombre del trabajo. En la línea de comando, este parámetro tiene la
propósito especial de señalar el inicio de un nuevo trabajo.

descripción=str
Descripción del trabajo legible por humanos. Se imprime cuando se ejecuta el trabajo, pero
de lo contrario no tiene ningún propósito especial.

directorio=str
Prefije los nombres de archivo con este directorio. Se utiliza para colocar archivos en una ubicación distinta a
`./ '. Puede especificar varios directorios separando los nombres con un ':'
personaje. Estos directorios se asignarán distribuidos equitativamente a los clones de trabajos.
crea con entumecidos siempre que utilicen nombres de archivo generados. Si es específico
nombre (s) de archivo están configurados fio usará el primer directorio listado y, por lo tanto, coincidirá
las nombre de archivo semántica que genera un archivo para cada clon si no se especifica, pero deja
todos los clones usan lo mismo si están configurados. Ver nombre de archivo para consideraciones sobre escapar
ciertos personajes en algunas plataformas.

nombre de archivo=str
fio normalmente crea un nombre de archivo basado en el nombre del trabajo, el número de hilo y el archivo
número. Si desea compartir archivos entre subprocesos en un trabajo o varios trabajos,
especifique un nombre de archivo para que cada uno de ellos anule el predeterminado. Si el motor de E / S está
basado en archivos, puede especificar una cantidad de archivos separando los nombres con un `: '
personaje. `- 'es un nombre reservado, que significa stdin o stdout, dependiendo del
conjunto de dirección de lectura / escritura. En Windows, se accede a los dispositivos de disco como \ .PhysicalDrive0
para el primer dispositivo, \ .PhysicalDrive1 para el segundo, etc. Nota: Windows y
FreeBSD evita el acceso de escritura a áreas del disco que contienen datos en uso (p. Ej.
sistemas de archivos). Si el nombre de archivo deseado necesita incluir dos puntos, entonces escape eso
con un carácter '\'. Por ejemplo, si el nombre del archivo es "/ dev / dsk / foo @ 3,0: c", entonces
usaría filename = "/ dev / dsk / foo @ 3,0 \: c".

nombre_archivo_formato=str
Si comparte varios archivos entre trabajos, generalmente es necesario tener fio
genere los nombres exactos que desee. De forma predeterminada, fio nombrará un archivo en función de
la especificación de formato de archivo predeterminado de nombretrabajo.númerotrabajo.númeroarchivo. Con este
opción, que se puede personalizar. Fio reconocerá y reemplazará lo siguiente
palabras clave en esta cadena:

$ nombre del trabajo
El nombre del proceso o subproceso de trabajo.

$ jobnum
El número incremental del proceso o subproceso de trabajo.

$ filenum
El número incremental del archivo para ese proceso o subproceso de trabajo.

Para que los trabajos dependientes compartan un conjunto de archivos, esta opción se puede configurar para tener fio
generar nombres de archivo que se comparten entre los dos. Por ejemplo, si
archivos de prueba. $ filenum se especifica, el archivo número 4 para cualquier trabajo se llamará
archivos de prueba.4. El defecto de $ nombre_trabajo. $ núm_trabajo. $ núm_archivo se utilizará si no hay otro
se proporciona un especificador de formato.

archivo de bloqueo=str
Por defecto, Fio no bloquea ningún archivo antes de hacerles IO. Si un archivo o archivo
el descriptor es compartido, fio puede serializar IO en ese archivo para obtener el resultado final
consistente. Esto es habitual para emular cargas de trabajo reales que comparten archivos. La cerradura
los modos son:

ninguna Sin bloqueo. Este es el predeterminado.

EXCLUSIVO PROGRAMA
Solo un hilo o proceso puede hacer IO a la vez, excluyendo todos los demás.

leer escribir
Bloqueo de lectura-escritura en el archivo. Muchos lectores pueden acceder al archivo en
al mismo tiempo, pero las escrituras obtienen acceso exclusivo.

abrir=str Abra recursivamente cualquier archivo debajo del directorio str.

leer escribir=str, rw=str
Tipo de patrón de E / S. Los valores aceptados son:

leer Lecturas secuenciales.

escribir Escrituras secuenciales.

recortar Recorte secuencial (solo dispositivos de bloque Linux).

leer
Lecturas aleatorias.

escribir a mano
Escribe al azar.

recortar
Recorte aleatorio (solo dispositivos de bloque Linux).

rw, leer escribir
Lecturas y escrituras secuenciales mixtas.

randw Lecturas y escrituras mixtas al azar.

escribir
Recorte y escriba cargas de trabajo mixtas. Los bloques se recortarán primero, luego
se escribirán los mismos bloques.

Para E / S mixtas, la división predeterminada es 50/50. Para ciertos tipos de io, el resultado puede
todavía estar un poco sesgado, ya que la velocidad puede ser diferente. Es posible especificar
una serie de IO para hacer antes de obtener una nueva compensación, esto se hace agregando un
`: hasta el final de la cadena dada. Para una lectura aleatoria, se vería como
rw = randread: 8 para pasar un modificador de desplazamiento con un valor de 8. Si el sufijo
se utiliza con un patrón de E / S secuencial, luego el valor especificado se agregará al
offset generado para cada IO. Por ejemplo, usando rw = escribir: 4k saltará 4k para
cada escritura. Convierte IO secuencial en IO secuencial con agujeros. Ver el
rw_secuenciador .

rw_secuenciador=str
Si se da un modificador de desplazamiento agregando un número al rw = línea, entonces
esta opción controla cómo ese número modifica el desplazamiento de E / S que se genera.
Los valores aceptados son:

secuencial
Generar desplazamiento secuencial

idéntico
Genere el mismo desplazamiento

secuencial sólo es útil para IO aleatorio, donde fio normalmente generaría un nuevo
compensación aleatoria para cada IO. Si agrega, por ejemplo, 8 a randread, obtendrá un nuevo
Desplazamiento aleatorio por cada 8 IO. El resultado sería una búsqueda para cada 8 IO,
en lugar de por cada IO. Usar rw = randread: 8 para especificar eso. Como IO secuencial es
ya secuencial, ajuste secuencial porque eso no daría lugar a ninguna
Diferencias. idéntico se comporta de manera similar, excepto que envía el mismo
compensar 8 veces antes de generar una nueva compensación.

kb_base=int
La unidad base de un kilobyte. La base predeterminada es 2 ^ 10, 1024. Almacenamiento
A los fabricantes les gusta usar 10 ^ 3 o 1000 como una unidad base diez en su lugar, por obvio
razones. Los valores permitidos son 1024 o 1000, siendo 1024 el valor predeterminado.

informes_rw_unificados=bool
Fio normalmente informa estadísticas por dirección de datos, lo que significa que leer,
escribir y recortar se contabilizan e informan por separado. Si esta opción se establece fio
suma los resultados y los informa como "mixtos" en su lugar.

repetir=bool
Sembrar el generador de números aleatorios utilizado para patrones de E / S aleatorios de una manera predecible
por lo que el patrón se puede repetir en todas las ejecuciones. Predeterminado: verdadero.

allrandrepeat=bool
Sembrar todos los generadores de números aleatorios de una manera predecible para que los resultados sean repetibles.
a través de carreras. Predeterminado: falso.

semilla de ranúnculo=int
Siembre los generadores de números aleatorios basados ​​en este valor de semilla, para poder controlar
qué secuencia de salida se está generando. Si no se establece, la secuencia aleatoria depende
en repetir ajuste.

Fallocate=str
Si la preasignación se realiza al colocar archivos. Los valores aceptados son:

ninguna No preasigne espacio.

POSIX Asignar previamente a través de posix_fallocate(3).

guardar Asignar previamente a través de Fallocate(2) con FALLOC_FL_KEEP_SIZE establecido.

0 Alias ​​compatible con versiones anteriores para 'ninguno'.

1 Alias ​​compatible con versiones anteriores para 'posix'.

Es posible que no esté disponible en todas las plataformas compatibles. 'keep' solo está disponible en Linux.
Si usa ZFS en Solaris, debe establecerlo en 'ninguno' porque ZFS no lo admite.
Predeterminado: 'posix'.

sugerencia_fadvise=bool
Uso posix_fadvise(2) para informar al kernel qué patrones de E / S es probable que sean
emitido. Predeterminado: verdadero.

fadvise_stream=int
Uso posix_fadvise(2) para informar al kernel a qué ID de secuencia pertenecen las escrituras emitidas
a. Solo compatible con Linux. Tenga en cuenta que esta opción puede cambiar en el futuro.

tamaño=int
Tamaño total de E / S para este trabajo. fio se ejecutará hasta que se hayan
transferido, a menos que esté limitado por otras opciones (tiempo de ejecución, por ejemplo, o
aumentado / disminuido por io_tamaño). A no ser que nrfiles y tamaño del archivo se dan opciones,
esta cantidad se dividirá entre los archivos disponibles para el trabajo. Si no está configurado,
fio utilizará el tamaño completo de los archivos o dispositivos dados. Si los archivos no
existen, se debe dar el tamaño. También es posible dar el tamaño como un porcentaje entre
1 y 100. Si se da el tamaño = 20%, fio utilizará el 20% del tamaño completo del
archivos o dispositivos.

io_tamaño=int, límite_io =int
Normalmente, fio opera dentro de la región establecida por tamaño, Lo que significa que el tamaño
La opción establece tanto la región como el tamaño de E / S que se va a realizar. A veces eso no es
Lo que quieras. Con esta opción, es posible definir solo la cantidad de IO
que debería hacer fio. Por ejemplo, si tamaño está configurado en 20G y límite_io está configurado en 5G,
fio realizará IO dentro de los primeros 20G, pero saldrá cuando se haya completado 5G. El
opuesto también es posible - si tamaño está configurado en 20G, y io_tamaño está configurado en 40G, entonces
fio hará 40G de IO dentro de la región 0..20G.

llenar_dispositivo=bool, llenar_fs=bool
Establece el tamaño en algo realmente grande y espera ENOSPC (no queda espacio en el dispositivo)
como condición de terminación. Solo tiene sentido con escritura secuencial. Para una lectura
carga de trabajo, el punto de montaje se completará primero y luego IO comenzó con el resultado. Esta
La opción no tiene sentido si se opera en un nodo de dispositivo sin formato, ya que el tamaño de ese
ya es conocido por el sistema de archivos. Además, escribir más allá del final del dispositivo
no devolverá ENOSPC allí.

tamaño del archivo=irango
Tamaños de archivos individuales. Puede ser un rango, en cuyo caso fio seleccionará tamaños para
archivos al azar dentro del rango dado, limitado a tamaño en total (si eso es
dado). Si tamaño del archivo no se especifica, cada archivo creado tiene el mismo tamaño.

agregar_archivo=bool
Realice E / S después del final del archivo. Normalmente, fio operará dentro del tamaño de
un archivo. Si esta opción está configurada, entonces fio se agregará al archivo en su lugar. Esto tiene
comportamiento idéntico al ajuste de compensación al tamaño de un archivo. Esta opción se ignora
en archivos no regulares.

tamaño de bloque=int [, int], bs=int [, int]
Tamaño de bloque para unidades de E / S. Predeterminado: 4k. Los valores para lecturas, escrituras y recortes se pueden
especificado por separado en el formato leer,escribir,recortar cualquiera de los cuales puede estar vacío para
deje ese valor en su valor predeterminado. Si no se da una coma al final, el resto
heredará el último valor establecido.

rango_tamaño_bloque=irange [, irange], rango bs=irange [, irange]
Especifique un rango de tamaños de bloques de E / S. La unidad de E / S emitida siempre será una
del tamaño mínimo, a menos que tamaño de bloque_no alineado Está establecido. Se aplica tanto a lecturas como a
escribe si solo se proporciona un rango, pero se puede especificar por separado con una coma
separando los valores. Ejemplo: bsrange = 1k-4k, 2k-8k. Ver también tamaño de bloque).

bsdividido=str
Esta opción permite un control aún más detallado de los tamaños de bloque emitidos, no solo
incluso se divide entre ellos. Con esta opción, puede ponderar varios tamaños de bloque para
control exacto de la E / S emitida para un trabajo que tiene tamaños de bloque mixtos. El formato de
la opción es bssplit = tamaño de bloque / porcentaje, opcionalmente agregando tantas definiciones
según sea necesario, separados por dos puntos. Ejemplo: bssplit = 4k / 10: 64k / 50: 32k / 40 emitiría
50% bloques de 64k, 10% bloques de 4k y 40% bloques de 32k. bsdividido también apoya dar
divisiones separadas para lecturas y escrituras. El formato es idéntico al bs opción
acepta, las partes de lectura y escritura se separan con una coma.

tamaño de bloque_no alineado, bs_no alineado
Si está configurado, cualquier tamaño en rango_tamaño_bloque puede ser usado. Por lo general, esto no funcionará con
E / S directa, ya que normalmente requiere alineación de sector.

bloquear alinear=int [, int], ba=int [, int]
En qué límite alinear las compensaciones de E / S aleatorias. El valor predeterminado es el mismo que 'tamaño de bloque'
el tamaño de bloque mínimo dado. La alineación mínima es típicamente 512b para usar directo
IO, aunque generalmente depende del tamaño del bloque de hardware. Esta opción es mutuamente
exclusivo con el uso de un mapa aleatorio para archivos, por lo que desactivará esa opción.

bs_is_seq_rand=bool
Si esta opción está configurada, fio usará la configuración normal de tamaño de bloque de lectura y escritura como
secuencial, aleatorio en su lugar. Cualquier lectura o escritura aleatoria utilizará el tamaño de bloque de ESCRITURA
configuraciones, y cualquier lectura o escritura secuencial usará la configuración de tamaño de bloque READ.

cero_buffers
Inicialice los búferes con todos ceros. Predeterminado: llenar búferes con datos aleatorios.

recargar_buffers
Si se da esta opción, fio rellenará los búferes de E / S en cada envío. El
el valor predeterminado es llenarlo solo en el momento de inicio y reutilizar esos datos. Solo tiene sentido si
zero_buffers no se especifica, naturalmente. Si la verificación de datos está habilitada,
refill_buffers también se habilita automáticamente.

scramble_buffers=bool
If recargar_buffers es demasiado costoso y el objetivo está utilizando la deduplicación de datos, entonces
configurar esta opción modificará ligeramente el contenido del búfer de E / S para anular el nivel normal
intentos de de-dupe. Esto no es suficiente para vencer una compresión de bloques más inteligente.
intentos, pero detendrá la deduplicación ingenua de bloques. Predeterminado: verdadero.

buffer_compress_porcentaje=int
Si se establece, entonces fio intentará proporcionar contenido de búfer de E / S (en ESCRITURAS) que
comprimir al nivel especificado. Fio hace esto proporcionando una combinación de datos aleatorios
y un patrón fijo. El patrón fijo es ceros o el patrón especificado
by patrón_búfer. Si se utiliza la opción de patrón, podría sesgar la compresión
proporción ligeramente. Tenga en cuenta que esto es por unidad de tamaño de bloque, para todo el archivo / disco
nivel de compresión que coincide con este ajuste. Tenga en cuenta que esto es por unidad de tamaño de bloque,
para el nivel de compresión de todo el archivo / disco que coincide con esta configuración, también querrá
establecer refill_buffers.

buffer_compress_chunk=int
See buffer_compress_porcentaje. Esta configuración permite a fio administrar qué tan grande
rangos de datos aleatorios y datos cero es. Sin este conjunto, fio proporcionará
buffer_compress_porcentaje de datos aleatorios de tamaño de bloque, seguidos del resto
puesto a cero. Con este ajuste en un tamaño de fragmento más pequeño que el tamaño del bloque, fio puede
alternar datos aleatorios y puestos a cero en todo el búfer de E / S.

patrón_búfer=str
Si se establece, fio llenará los búferes de E / S con este patrón. Si no se establece, el contenido de
Los búferes de E / S se definen mediante las otras opciones relacionadas con el contenido del búfer. El ajuste
puede ser cualquier patrón de bytes y puede tener el prefijo 0x para valores hexadecimales. Puede
también debe ser una cadena, donde la cadena debe estar envuelta con "", por ejemplo:
patrón_búfer= "abcd"
or
patrón_búfer= -12
or
patrón_búfer= 0xmuerto

También puedes combinar todo junto en cualquier orden:

patrón_búfer= 0xdeadface "abcd" -12

porcentaje_deduplicado=int
Si se establece, fio generará este porcentaje de búferes idénticos al escribir. Estos
los búferes serán deducibles naturalmente. El contenido de los búferes depende de lo que
Se han establecido otros ajustes de compresión de búfer. Es posible tener el
amortiguadores individuales totalmente comprimibles o no en absoluto. Esta opción solamente
controla la distribución de búferes únicos.

nrfiles=int
Número de archivos que se utilizarán para este trabajo. Predeterminado: 1.

openfiles=int
Número de archivos para mantener abiertos al mismo tiempo. Defecto: nrfiles.

tipo_de_servicio_de_archivo=str
Define cómo se seleccionan los archivos a reparar. Se definen los siguientes tipos:

azar Elija un archivo al azar.

roundrobin
Round robin sobre archivos abiertos (predeterminado).

secuencial
Realice cada archivo del conjunto de forma secuencial.

El número de E / S a emitir antes de cambiar a un nuevo archivo se puede especificar mediante
anexando `:int'al tipo de servicio.

iomotor=str
Define cómo el trabajo emite E / S. Se definen los siguientes tipos:

sincronizar Basic leer(2) o escribir(2) E / S. buscar(2) se utiliza para colocar la E / S
ubicación.

sincronización psíquica Basic predicar(2) o escribir(2) E / S.

vsync Basic leer(2) o escribirv(2) E / S. Emulará las colas al fusionarse
IO adyacentes en un solo envío.

sincronización pv Basic preadv(2) o pwritev(2) E / S.

libaio E / S asíncronas nativas de Linux. Este ioengine define el motor específico
.

posixaio
E / S asincrónicas POSIX usando aio_leer(3) y aio_escribir(3).

solarisaio
E / S asíncronas nativas de Solaris.

Windowsaio
E / S asíncronas nativas de Windows.

mmap El archivo está mapeado en memoria con mmap(2) y datos copiados usando memcpy(3).

empalme empalme(2) se utiliza para transferir los datos y empalme virtual(2) transferir
datos del espacio de usuario al kernel.

syslet-rw
Utilice las llamadas al sistema syslet para hacer que la lectura / escritura sea asíncrona.

sg SCSI genérico sg v3 E / S. Puede ser sincrónico usando SG_IO
ioctl, o si el objetivo es un dispositivo de caracteres sg, usamos leer(2) y
escribir(2) para E / S asíncronas.

nulo No transfiere ningún dato, solo finge. Se utiliza principalmente para hacer ejercicio.
fio en sí mismo y con fines de depuración y prueba.

red Transfiera a través de la red. Se puede definir el protocolo a utilizar
con el protocolo parámetro. Dependiendo del protocolo, nombre de archivo,
hostname, Puertoo escuchan debe especificarse. Este io motor define
opciones específicas del motor.

empalme de red
Me gusta red, pero usa empalme(2) y empalme virtual(2) para mapear datos y
enviar recibir. Este ioengine define las opciones específicas del motor.

CPU No transfiere ningún dato, pero quema ciclos de CPU de acuerdo con carga de cpu
y cpuciclos parámetros.

Guasi El motor de E / S GUASI es la llamada al sistema asincrónica del espacio de usuario genérico
Enfoque de interfaz para E / S asincrónicas.
Verhttp://www.xmailserver.org/guasi-lib.html>.

rdma El motor de E / S RDMA admite la semántica de memoria RDMA
(RDMA_WRITE / RDMA_READ) y semántica de canal (Enviar / Recv) para el
Protocolos InfiniBand, RoCE e iWARP.

externo
Carga un archivo de objeto de motor de E / S externo. Anexar el nombre de archivo del motor
como ':ruta del motor'.

Falloc
Motor de IO que realiza una llamada regular de Fallocate nativo de Linux a
simular la transferencia de datos como fio ioengine
DDIR_READ falla (, mode = FALLOC_FL_KEEP_SIZE,)
DIR_WRITE no falla (, modo = 0)
DDIR_TRIM no falla (, mode =
FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE)

e4defrag
Motor IO que hace ioctls EXT4_IOC_MOVE_EXT regulares para simular
solicitud de actividad de desfragmentación al evento DDIR_WRITE

rbd Motor IO que admite acceso directo a dispositivos de bloque Ceph Rados (RBD)
a través de librbd sin la necesidad de utilizar el controlador rbd del kernel. Esta
ioengine define las opciones específicas del motor.

gfapi Uso de la interfaz de sincronización libgfapi de Glusterfs para acceder directamente a Glusterfs
volúmenes sin tener que pasar por FUSE. Este io motor define
opciones específicas del motor.

gfapi_async
Uso de la interfaz asíncrona libgfapi de Glusterfs para acceder directamente a
Volúmenes de Glusterfs sin tener que pasar por FUSE. Este ioengine
define las opciones específicas del motor.

libhdfs
Leer y escribir a través de Hadoop (HDFS). El nombre de archivo La opción se usa para
especificar host, puerto del nodo de nombre hdfs para conectarse. Este motor
interpreta las compensaciones de forma un poco diferente. En HDFS, los archivos una vez creados
no se puede modificar. Por tanto, las escrituras aleatorias no son posibles. Imitar
esto, el motor libhdfs espera que se creen un montón de archivos pequeños sobre
HDFS, y el motor seleccionará aleatoriamente un archivo de esos archivos según
en el desplazamiento generado por fio backend. (vea el archivo de trabajo de ejemplo para
cree dichos archivos, use la opción rw = write). Tenga en cuenta que es posible que desee
para configurar las variables de entorno necesarias para trabajar con hdfs / libhdfs
correctamente.

mtd Leer, escribir y borrar un dispositivo de caracteres MTD (por ejemplo, / dev / mtd0).
Los descartes se tratan como borrados. Dependiendo del dispositivo subyacente
tipo, la E / S puede tener que seguir un patrón determinado, por ejemplo, en NAND,
escribir secuencialmente para borrar bloques y descartar antes
sobrescritura. El modo de recorte de escritura funciona bien para esta restricción.

ioprofundidad=int
Número de unidades de E / S para mantener en vuelo contra el archivo. Tenga en cuenta que aumentando
iodepth más allá de 1 no afectará a los motores síncronos (a excepción de pequeños grados
cuando verify_async está en uso). Incluso los motores asincrónicos pueden imponer restricciones del sistema operativo que provocan
la profundidad deseada no se logrará. Esto puede suceder en Linux cuando se usa libaio
y no poner de reservas= 1, ya que la E / S almacenada en búfer no es asíncrona en ese sistema operativo. Mantener vigilado
la distribución de profundidad de IO en la salida de fio para verificar que la profundidad alcanzada sea la
previsto. Predeterminado: 1.

io depth_batch=int
Número de E / S para enviar a la vez. Defecto: ioprofundidad.

io depth_batch_complete=int
Esto define cuántas piezas de IO recuperar a la vez. El valor predeterminado es 1, que
significa que pediremos un mínimo de 1 IO en el proceso de recuperación del
núcleo. La recuperación de E / S continuará hasta que alcancemos el límite establecido por profundidad_baja. Si
esta variable se establece en 0, entonces fio siempre buscará eventos completados antes
hacer cola más IO. Esto ayuda a reducir la latencia de E / S, a costa de más sistema de recuperación
llamadas.

profundidad_baja=int
Marca de agua baja que indica cuándo comenzar a llenar la cola nuevamente. Defecto: ioprofundidad.

io_submit_mode=str
Esta opción controla cómo fio envía el IO al motor IO. El valor predeterminado es
en línea, lo que significa que los subprocesos de trabajo de fio envían y obtienen IO directamente. Si está configurado
a descargar, los subprocesos de trabajo descargarán el envío de E / S a un grupo dedicado de E / S
hilos. Esto requiere algo de coordinación y, por lo tanto, tiene un poco de sobrecarga adicional,
especialmente para E / S de menor profundidad de cola, donde puede aumentar las latencias. El beneficio es
que fio puede administrar las tasas de envío independientemente de las tasas de finalización del dispositivo.
Esto evita informes de latencia sesgados si IO vuelve a aparecer en el lado del dispositivo (el
problema de omisión coordinada).

de reservas=bool
Si es verdadero, use E / S sin búfer (generalmente O_DIRECT). Predeterminado: falso.

atómico=bool
Si el valor es verdadero, intente utilizar la E / S directa atómica. Se garantiza que las escrituras atómicas
ser estable una vez reconocido por el sistema operativo. Solo Linux es compatible con O_ATOMIC
en estos momentos.

Amortiguado=bool
Si es verdadero, use E / S con búfer. Esto es lo opuesto al de reservas parámetro. Defecto:
verdadera.

compensar=int
Desplazamiento en el archivo para iniciar la E / S. Los datos anteriores a la compensación no se modificarán.

incremento_compensación=int
Si se proporciona esto, entonces la compensación real se convierte en compensación + compensación_incremento *
thread_number, donde el número de hilo es un contador que comienza en 0 y es
incrementado para cada sub-trabajo (es decir, cuando se especifica la opción numjobs). Esta opción
es útil si hay varios trabajos que están destinados a operar en un archivo en
segmentos disjuntos paralelos, con espaciado uniforme entre los puntos de partida.

número_ios=int
Fio normalmente realizará IO hasta que haya agotado el tamaño de la región establecido por
tamaño, o si agota el tiempo asignado (o encuentra una condición de error). Con este
configuración, el rango / tamaño se puede configurar independientemente del número de E / S a realizar.
Cuando fio alcance este número, saldrá normalmente e informará el estado. Tenga en cuenta que
esto no extiende la cantidad de IO que se hará, solo detendrá fio si
esta condición se cumple antes que otros criterios de finalización del trabajo.

fsync=int
Cuántas E / S realizar antes de emitir una fsync(2) de datos sucios. Si es 0, no
sincronizar. Predeterminado: 0.

sincronización de datos=int
Me gusta fsync, pero usa sincronización de datos(2) en lugar de sincronizar solo las partes de datos del archivo.
Predeterminado: 0.

escribir_barrera=int
Haz que cada enésimo escriba una barrera.

sincronizar_archivo_rango=str: int
Uso sincronizar_archivo_rango(2) para cada val número de operaciones de escritura. Fio rastreará
rango de escrituras que han sucedido desde el último sincronizar_archivo_rango(2) llamar. str puede
actualmente ser uno o más de:

esperar_antes
SYNC_FILE_RANGE_WAIT_ANTES

escribir SYNC_FILE_RANGE_WRITE

esperar_después
SYNC_FILE_RANGE_WRITE

Entonces, si hace sync_file_range = wait_before, escriba: 8, fio usaría
SYNC_FILE_RANGE_WAIT_ANTES | SYNC_FILE_RANGE_WRITE por cada 8 escrituras. Ver también
las sincronizar_archivo_rango(2) página de manual. Esta opción es específica de Linux.

exagerar=bool
Si escribe, configure el archivo primero y sobrescriba. Predeterminado: falso.

end_fsync=bool
Sincronice el contenido del archivo cuando haya finalizado una etapa de escritura. Predeterminado: falso.

fsync_on_close=bool
Si es verdadero, sincronice el contenido del archivo al cerrar. Esto difiere de end_fsync en que lo hará
suceden en cada cierre, no solo al final del trabajo. Predeterminado: falso.

rwmixread=int
Porcentaje de una carga de trabajo mixta que debe leerse. Predeterminado: 50.

rwmixescribir=int
Porcentaje de una carga de trabajo mixta que debe escribirse. Si rwmixread y rwmixescribir
se dan y no suman 100%, el último de los dos anula al primero. Esta
puede interferir con una configuración de velocidad determinada, si se le pide a fio que limite las lecturas o escrituras
a un cierto ritmo. Si ese es el caso, entonces la distribución puede estar sesgada.
Predeterminado: 50.

distribución_aleatoria=str: flotar
Por defecto, fio usará una distribución aleatoria completamente uniforme cuando se le solicite
realizar E / S aleatoria. A veces es til sesgar la distribucin en especficos
formas, asegurando que algunas partes de los datos estén más calientes que otras. Fio incluye
los siguientes modelos de distribución:

azar Distribución aleatoria uniforme

zip Distribución zipf

Pareto Distribución de Pareto

Cuando se usa una distribución zipf o pareto, también se necesita un valor de entrada para
definir el patrón de acceso. Para zipf, este es zipf theta. Para Pareto, es el
poder de pareto. Fio incluye un programa de prueba, genzipf, que se puede utilizar para visualizar lo que
los valores de entrada dados cederán en términos de tasas de aciertos. Si quisieras usar zipf
con un theta de 1.2, usaría random_distribution = zipf: 1.2 como opción. Si un
se utiliza un modelo no uniforme, fio deshabilitará el uso del mapa aleatorio.

porcentaje_aleatorio=int
Para una carga de trabajo aleatoria, establezca qué tan grande debe ser aleatorio un porcentaje. Esto por defecto es
100%, en cuyo caso la carga de trabajo es completamente aleatoria. Se puede configurar desde cualquier lugar desde
De 0 a 100. Establecerlo en 0 haría que la carga de trabajo fuera completamente secuencial. Es posible
para establecer diferentes valores para lecturas, escrituras y recortes. Para hacerlo, simplemente use una coma
lista separada. Ver tamaño de bloque.

mapanorandommap
Normalmente fio cubrirá todos los bloques del archivo al realizar E / S aleatorias. Si esto
se proporciona un parámetro, se elegirá un nuevo desplazamiento sin mirar las E / S pasadas
historia. Este parámetro es mutuamente excluyente con verificar.

mapasoftrandom=bool
See mapanorandommap. Si fio se ejecuta con el mapa de bloques aleatorios habilitado y no
asignar el mapa, si esta opción está configurada, continuará sin un bloque aleatorio
mapa. Como la cobertura no será tan completa como con mapas aleatorios, esta opción es
desactivado por defecto.

generador_aleatorio=str
Fio admite los siguientes motores para generar compensaciones de E / S para E / S aleatorias:

tausworthe
Fuerte generador de números aleatorios de 2 ^ 88 ciclos

lfsr Generador de registro de desplazamiento de retroalimentación lineal

tausworthe64
Fuerte generador de números aleatorios de 64 ^ 2 ciclos de 258 bits

Tausworthe es un potente generador de números aleatorios, pero requiere seguimiento en
las
side si queremos asegurarnos de que los bloques solo se lean o escriban una vez. LFSR
garantiza que nunca generamos el mismo desplazamiento dos veces, y también es menos
costoso computacionalmente. Sin embargo, no es un verdadero generador aleatorio, aunque para IO
propósitos es típicamente lo suficientemente bueno. LFSR solo funciona con tamaños de bloque único, no
con cargas de trabajo que utilizan varios tamaños de bloque. Si se usa con tal carga de trabajo, fio puede
leer o escribir algunos bloques varias veces.

agradable=int
Ejecute el trabajo con un buen valor dado. Ver agradable(2).

prio=int
Establezca el valor de prioridad de E / S de este trabajo entre 0 (más alto) y 7 (más bajo). Ver
ionico(1).

prioclase=int
Configure la clase de prioridad de E / S. Ver ionico(1).

tiempo para pensar=int
Trabajo detenido para un número determinado de microsegundos entre la emisión de E / S.

pensartiempo_girar=int
Pretenda gastar tiempo de CPU durante un número determinado de microsegundos, durmiendo el resto de
el tiempo especificado por tiempo para pensar. Solo válido si tiempo para pensar se establece.

pensar_bloques_de_tiempo=int
Solo es válido si se establece el tiempo de reflexión: controle cuántos bloques emitir, antes de esperar
tiempo para pensar microsegundos. Si no se establece, el valor predeterminado es 1, lo que hará que fio espere
tiempo para pensar microsegundos después de cada bloque. Esto efectivamente hace que cualquier profundidad de cola
configuración redundante, ya que no se pondrá más de 1 IO en cola antes de que tengamos que
complételo y haga nuestro tiempo de reflexión. En otras palabras, esta configuración limita eficazmente
profundidad de la cola si esta última es mayor. Predeterminado: 1.

y =int
Limite el ancho de banda utilizado por este trabajo. El número está en bytes / seg, el sufijo normal
se aplican las reglas. Puedes usar y = 500k para limitar las lecturas y escrituras a 500k cada una, o usted
Puede especificar lecturas y escrituras por separado. Utilizando y = 1 m, 500 k limitarían las lecturas a
1 MB / seg y escribe a 500 KB / seg. Se puede limitar solo las lecturas o escrituras con
y =, 500k o y = 500k ,. El primero solo limitará las escrituras (a 500 KB / seg), el
este último solo limitará las lecturas.

tasamin=int
Decir fio hacer todo lo posible para mantener al menos el ancho de banda dado. Defecto
cumplir con este requisito provocará la salida del trabajo. El mismo formato que y is
utilizado para la separación de lectura y escritura.

tasa_iops=int
Limite el ancho de banda a esta cantidad de IOPS. Básicamente lo mismo que la tasa, solo
especificado independientemente del ancho de banda. El mismo formato que y se usa para leer vs
escribir separación. Si tamaño de bloque es un rango, el tamaño de bloque más pequeño se utiliza como
métrico.

tasa_iops_min=int
Si no se alcanza esta tasa de E / S, el trabajo se cerrará. El mismo formato que y se utiliza
para la separación de lectura y escritura.

ciclo de tasas=int
Ancho de banda promedio para y y tasamin durante este número de milisegundos. Defecto:
1000ms.

latencia_objetivo=int
Si se establece, fio intentará encontrar el punto de rendimiento máximo que la carga de trabajo dada
se ejecutará mientras mantiene una latencia por debajo de este objetivo. Los valores se dan en
microsegundos. Ver latencia_ventana y latencia_percentil.

latencia_ventana=int
Usado con latencia_objetivo para especificar la ventana de muestra en la que se ejecuta el trabajo
diferentes profundidades de cola para probar el rendimiento. El valor se da en microsegundos.

latencia_percentil=flotar
El porcentaje de IO que deben estar dentro de los criterios especificados por
latencia_objetivo y latencia_ventana. Si no se establece, este valor predeterminado es 100.0, lo que significa que
todas las E / S deben ser iguales o inferiores al valor establecido por latencia_objetivo.

latencia_máxima=int
Si se establece, fio saldrá del trabajo si excede esta latencia máxima. Saldrá con
un error ETIME.

pumask=int
Establezca la afinidad de CPU para este trabajo. int es una máscara de bits de las CPU permitidas en las que se puede ejecutar el trabajo.
See sched_setaffinity(2).

cpus_permitido=str
Igual que pumask, pero permite una lista delimitada por comas de números de CPU.

cpus_allowed_policy=str
Establezca la política de cómo fio distribuye las CPU especificadas por cpus_permitido or
pumask. Se admiten dos políticas:

compartido Todos los trabajos compartirán el conjunto de CPU especificado.

dividido Cada trabajo obtendrá una CPU única del conjunto de CPU.

compartido es el comportamiento predeterminado, si no se especifica la opción. Si dividido is
especificado, entonces fio asignará una CPU por trabajo. Si no se proporcionan suficientes CPU para
los trabajos enumerados, entonces fio redondeará las CPU en el conjunto.

numa_cpu_nodos=str
Configure este trabajo para que se ejecute en las CPU de los nodos NUMA especificados. Los argumentos permiten coma
lista delimitada de números de CPU, rangos AB o 'todos'.

numa_mem_policy=str
Configure la política de memoria de este trabajo y los nodos NUMA correspondientes. Formato de los argumentos:

[: ]

modo es una de las siguientes políticas de memoria:

defecto preferir, unir, intercalar local

tu préstamo estudiantil y local política de memoria, no lista de nodos is
necesitaba ser especificado. Para preferir, solo se permite un nodo. Para se unen y
intercalar, lista de nodos permite una lista delimitada por comas de números, rangos AB o "todos".

retraso del inicio=irango
Retrasar el inicio del trabajo durante el número especificado de segundos. Admite todos los sufijos de tiempo
para permitir la especificación de horas, minutos, segundos y milisegundos; los segundos son
el predeterminado si se omite una unidad. Se puede dar como un rango que causa cada hilo.
para elegir aleatoriamente fuera del rango.

tiempo de ejecución=int
Termine el procesamiento después del número especificado de segundos.

basado en tiempo
Si se da, ejecute para el especificado tiempo de ejecución duración incluso si los archivos están completamente
leído o escrito. La misma carga de trabajo se repetirá tantas veces como tiempo de ejecución
permite.

rampa_tiempo=int
Si se establece, fio ejecutará la carga de trabajo especificada durante este período de tiempo antes de iniciar sesión
cualquier número de rendimiento. Útil para dejar que el rendimiento se estabilice antes de iniciar sesión
resultados, minimizando así el tiempo de ejecución necesario para obtener resultados estables. Tenga en cuenta que el
rampa_tiempo se considera adelanto en el tiempo para un trabajo, por lo que aumentará el total
tiempo de ejecución si se especifica un tiempo de espera o tiempo de ejecución especial.

invalidar=bool
Invalide la memoria caché del búfer para el archivo antes de iniciar la E / S. Predeterminado: verdadero.

sincronizar=bool
Utilice E / S síncronas para escrituras almacenadas en búfer. Para la mayoría de los motores de E / S, este
significa usar O_SYNC. Predeterminado: falso.

Iomem=str, Miembro=str
Método de asignación para el búfer de la unidad de E / S. Los valores permitidos son:

malloc Asignar memoria con malloc(3).

shm Utilice búferes de memoria compartida asignados a través de shmget(2).

enorme
Igual que shm, pero use páginas enormes como respaldo.

mmap Uso mmap(2) para asignación. Utiliza memoria anónima a menos que un nombre de archivo
se da después de la opción en el formato `:presentar'.

enorme
Igual que mmap, pero utilice archivos de gran tamaño como respaldo.

La cantidad de memoria asignada es la máxima permitida tamaño de bloque para el trabajo
multiplicado por ioprofundidad. For enorme or enorme para funcionar, el sistema debe tener libre
enormes páginas asignadas. enorme también necesita tener hugetlbfs montado, y presentar debe
apuntar allí. Al menos en Linux, las páginas grandes deben asignarse manualmente. Ver
/ proc / sys / vm / nr_hugehages y la documentación para eso. Normalmente solo necesitas
repetir un número apropiado, por ejemplo, hacer eco de 8 asegurará que el sistema operativo tenga 8 páginas enormes
Listo para usar.

iomem_align=int, mem_align=int
Esto indica la alineación de la memoria de los búferes de memoria de E / S. Tenga en cuenta que el dado
La alineación se aplica al primer búfer de la unidad IO, si se usa ioprofundidad la alineación de
los siguientes búferes son dados por el bs usado. En otras palabras, si usa un bs esa
es un múltiplo del tamaño de la página en el sistema, todos los búferes se alinearán con este
valor. Si usa un bs que no está alineado con la página, la alineación de las E / S posteriores
búferes de memoria es la suma de los iomem_align y bs usado.

tamaño de página enorme=int
Define el tamaño de una página enorme. Debe ser al menos igual a la configuración del sistema.
Debe ser un múltiplo de 1 MB. Predeterminado: 4 MB.

salir todo
Termine todos los trabajos cuando termine uno. Predeterminado: espere a que finalice cada trabajo.

tiempo de espera=int
Cálculos de ancho de banda promedio durante el tiempo dado en milisegundos. Defecto:
500ms.

iopsavgtime=int
Cálculos de IOPS promedio durante el tiempo dado en milisegundos. Predeterminado: 500ms.

crear_serializar=bool
Si es verdadero, serialice la creación de archivos para los trabajos. Predeterminado: verdadero.

crear_fsync=bool
fsync(2) archivo de datos después de la creación. Predeterminado: verdadero.

crear_al_abrir=bool
Si es verdadero, los archivos no se crean hasta que el trabajo los abre para E / S.

crear_solo=bool
Si es verdadero, fio solo ejecutará la fase de configuración del trabajo. Si es necesario distribuir los archivos
o actualizado en disco, solo eso se hará. El contenido real del trabajo no es
ejecutado.

permitir_archivo_crear=bool
Si es verdadero, fio puede crear archivos como parte de su carga de trabajo. Este es el
comportamiento por defecto. Si esta opción es falsa, entonces fio generará un error si los archivos
necesita usar no existe todavía. Predeterminado: verdadero.

permitir_montar_escribir=bool
Si no se establece, fio abortará los trabajos que son destructivos (por ejemplo, que escriben) a lo que
parece ser un dispositivo montado o una partición. Esto debería ayudar a captar la creación
pruebas destructivas inadvertidas, sin darse cuenta de que la prueba destruirá datos en
el sistema de archivos montado. Predeterminado: falso.

pre_leer=bool
Si se da esto, los archivos se leerán previamente en la memoria antes de iniciar el IO dado.
operación. Esto también borrará el invalidar bandera, ya que es inútil prever
leer y luego soltar el caché. Esto solo funcionará para motores IO que sean buscables,
ya que le permiten leer los mismos datos varias veces. Por lo tanto, no funcionará en
por ejemplo, E / S de red o empalme.

desconectar=bool
Desvincular archivos de trabajo cuando haya terminado. Predeterminado: falso.

bucles=int
Especifica el número de iteraciones (ejecuciones de la misma carga de trabajo) de este trabajo.
Predeterminado: 1.

verificar_only=bool
No realice la carga de trabajo especificada, solo verifique que los datos aún coincidan con los anteriores
invocación de esta carga de trabajo. Esta opción permite verificar datos varias veces al mismo tiempo.
una fecha posterior sin sobrescribirla. Esta opción tiene sentido solo para cargas de trabajo
que escriben datos y no admite cargas de trabajo con la basado en tiempo conjunto de opciones.

hacer_verificar=bool
Ejecute la fase de verificación después de una fase de escritura. Solo válido si verificar Está establecido. Defecto:
verdadera.

verificar=str
Método de verificación del contenido del archivo después de cada iteración del trabajo. Cada
El método de verificación también implica la verificación de un encabezado especial, que está escrito
al comienzo de cada bloque. Este encabezado también incluye metainformación, como
desplazamiento del bloque, número de bloque, marca de tiempo cuando se escribió el bloque, etc.
verificar= str se puede combinar con verificar_patrón= opción str. Los valores permitidos son:

md5 crc16 crc32 crc32c crc32c-intel crc64 crc7 sha256 sha512 sha1 xhash
Almacene la suma de comprobación adecuada en el encabezado de cada bloque. crc32c-intel
está impulsado por SSE4.2 acelerado por hardware, vuelve a crc32c normal
si no es compatible con el sistema.

meta Esta opción está obsoleta, ya que ahora la metainformación está incluida en
El encabezado de verificación genérico y la meta verificación se realizan de forma predeterminada.
Para obtener información detallada, consulte la descripción del verificar= str
ajuste. Esta opción se mantiene debido a la compatibilidad con versiones antiguas.
configuraciones. No lo uses.

patrón
Verifique un patrón estricto. Normalmente, fio incluye un encabezado con algunos
información básica y suma de verificación, pero si esta opción está configurada, solo
el patrón específico establecido con verificar_patrón es verificado.

nulo Finge verificar. Se utiliza para probar los componentes internos.

Esta opción se puede utilizar para pruebas de quemado repetidas de un sistema para asegurarse de que
los datos escritos también se leen correctamente. Si la dirección de datos dada es una lectura
o lectura aleatoria, fio asumirá que debe verificar un archivo escrito previamente. Si
la dirección de datos incluye cualquier forma de escritura, la verificación será del nuevo
datos escritos.

verificarordenar=bool
Si es verdadero, los bloques de verificación escritos se ordenan si fio considera que es más rápido leerlos
de vuelta de forma ordenada. Predeterminado: verdadero.

verificarsort_nr=int
Precargue y clasifique los bloques de verificación para una carga de trabajo de lectura.

verificar_compensación=int
Cambie el encabezado de verificación con datos en otro lugar del bloque antes de escribir.
Se vuelve a cambiar antes de verificar.

verificar_intervalo=int
Escriba el encabezado de verificación para este número de bytes, que debe dividir
tamaño de bloque. Defecto: tamaño de bloque.

verificar_patrón=str
Si se establece, fio llenará los búferes de io con este patrón. Fio tiene por defecto el llenado
con bytes totalmente aleatorios, pero a veces es interesante completar con un conocido
patrón para fines de verificación de io. Dependiendo del ancho del patrón, fio
llenará 1/2/3/4 bytes del búfer en ese momento (puede ser un decimal o un
número hexadecimal). El verify_pattern si es mayor que una cantidad de 32 bits tiene que ser hexadecimal
número que comienza con "0x" o "0X". Usar con verificar= str. También,
verify_pattern admite el formato% o, lo que significa que para cada bloque el desplazamiento será
escrito y luego verificado, por ejemplo:
verificar_patrón=% o
O use una combinación de todo:

verificar_patrón= 0xff% o "abcd" -21

verificar_fatal=bool
Si es verdadero, salga del trabajo en la primera falla de verificación observada. Predeterminado: falso.

verificar_volcado=bool
Si se establece, volca el contenido tanto del bloque de datos original como del bloque de datos que
leer el disco en archivos. Esto permite un análisis posterior para inspeccionar qué tipo de
se produjo la corrupción de datos. Desactivado por defecto.

verificar_async=int
Fio normalmente verificará IO en línea desde el hilo de envío. Esta opción toma un
entero que describe cuántos subprocesos de descarga asíncronos se deben crear para la verificación de E / S
en su lugar, causando que fio descargue el deber de verificar el contenido de IO a uno o más
hilos separados. Si usa esta opción de descarga, incluso los motores de sincronización de E / S pueden beneficiarse
de usar un ioprofundidad configuración superior a 1, ya que les permite tener IO en vuelo
mientras se ejecutan las verificaciones.

verificar_async_cpus=str
Dile a fio que establezca la afinidad de CPU dada en los subprocesos de verificación de E / S asíncronos. Ver
cpus_permitido para el formato utilizado.

verificar_backlog=int
Fio normalmente verificará el contenido escrito de un trabajo que utiliza verificar una vez
ese trabajo se ha completado. En otras palabras, todo está escrito, entonces todo está
leer y verificar. Es posible que desee verificar continuamente en lugar de una variedad de
razones. Fio almacena los metadatos asociados con un bloque de E / S en la memoria, por lo que para
grandes cargas de trabajo de verificación, se utilizaría bastante memoria para mantener esta meta
datos. Si esta opción está habilitada, fio escribirá solo N bloques antes de verificar
estos bloques.

verificar_backlog_batch=int
Controle cuántos bloques verificará fio si verify_backlog está configurado. Si no se establece,
predeterminado al valor de verificar_backlog (lo que significa que toda la cola se vuelve a leer y
verificado). Si verificar_backlog_batch es menor que verificar_backlog entonces no todos los bloques
será verificado, si verificar_backlog_batch Es mas grande que verificar_backlog, algunos
Los bloques se verificarán más de una vez.

recorte_porcentaje=int
Número de bloques de verificación para descartar / recortar.

recortar_verificar_cero=bool
Verifique que los bloques recortados / descartados se devuelvan como ceros.

trim_backlog=int
Recorte después de escribir este número de bloques.

trim_backlog_batch=int
Recorte este número de bloques de E / S.

experimental_verificar=bool
Habilite la verificación experimental.

verificar_estado_guardar=bool
Cuando un trabajo sale durante la fase de escritura de una carga de trabajo de verificación, guarde su
Expresar. Esto permite que fio se reproduzca hasta ese punto, si el estado de verificación está cargado
para la fase de lectura de verificación.

verificar_estado_carga=bool
Si se utilizó un activador de verificación de terminación, fio almacena el estado de escritura actual de
cada hilo. Esto se puede utilizar en el momento de la verificación para que fio sepa hasta qué punto
debe verificar. Sin esta información, fio ejecutará un pase de verificación completo,
según la configuración del archivo de trabajo utilizado.

Stonewall , esperar_por_anterior
Espere a que salgan los trabajos anteriores en el archivo de trabajo antes de iniciar este.
Stonewall implica nuevo grupo.

nuevo grupo
Inicie un nuevo grupo de informes. Si no se proporciona, todos los trabajos de un archivo serán parte del
mismo grupo de informes, a menos que estén separados por un muro de piedra.

entumecidos=int
Número de clones (procesos / subprocesos que realizan la misma carga de trabajo) de este trabajo.
Predeterminado: 1.

informes_de_grupo
Si está configurado, mostrar informes por grupo en lugar de por trabajo cuando entumecidos está especificado.

o fresa de hueso denso Usar hilos creados con pthread_create(3) en lugar de procesos creados con
tenedor(2).

zoneize=int
Divida el archivo en zonas del tamaño especificado en bytes. Ver zonekip.

rango de zona=int
Indique el tamaño de una zona IO. Ver zonekip.

zonekip=int
Omita el número especificado de bytes cuando zoneize Se han leído bytes de datos.

escribir_iolog=str
Escriba los patrones de E / S emitidos en el archivo especificado. Especifique un archivo separado para
cada trabajo; de lo contrario, los iologs se intercalarán y el archivo puede estar dañado.

leer_iolog=str
Reproducir los patrones de E / S contenidos en el archivo especificado generado por escribir_iolog,
o puede ser un trazo negro archivo binario.

repetición_no_stall=int
Al reproducir patrones de E / S usando leer_iolog el comportamiento predeterminado intenta
respetar la información de tiempo entre E / S. Habilitar repetición_no_stall hace que las E / S
ser reproducido lo más rápido posible sin dejar de respetar el orden.

repetición_redirect=str
Al reproducir patrones de E / S usando leer_iolog el comportamiento predeterminado es reproducir el
IOPS en el dispositivo mayor / menor desde el que se registró cada IOP. Ajuste
repetición_redirect hace que todas las IOPS se reproduzcan en el único dispositivo especificado
independientemente del dispositivo desde el que se grabó.

reproducir_alinear=int
Forzar la alineación de las compensaciones y longitudes de E / S en una traza a esta potencia de valor 2.

escala_de_reproducción=int
El sector de escala compensa las compensaciones por este factor al reproducir trazas.

registros_por_trabajo=bool
Si se establece, esto genera un registro bw / clat / iops con nombres de archivo privados por archivo. Que no
establecido, los trabajos con nombres idénticos compartirán el nombre del archivo de registro. Predeterminado: verdadero.

escribir_bw_log=str
Si se proporciona, escriba un registro de ancho de banda de los trabajos en este archivo de trabajo. Puede usarse para almacenar
datos del ancho de banda de los trabajos a lo largo de su vida. El incluido
El script fio_generate_plots usa gnuplot para convertir estos archivos de texto en agradables gráficos.
See escribir_lat_log para el comportamiento del nombre de archivo dado. Para esta opción, el sufijo es
_bw.x.log, donde x es el índice del trabajo (1..N, donde N es el número de trabajos).
If registros_por_trabajo es falso, entonces el nombre del archivo no incluirá el índice del trabajo.

escribir_lat_log=str
Igual que escribir_bw_log, pero escribe latencias de finalización de E / S. Si no se proporciona un nombre de archivo
con esta opción, se utiliza el nombre de archivo predeterminado de "jobname_type.x.log", donde x es
el índice del trabajo (1..N, donde N es el número de trabajos). Incluso si el nombre del archivo es
dado, fio aún agregará el tipo de registro. Si registros_por_trabajo es falso, entonces el
nombre de archivo no incluirá el índice del trabajo.

escribir_iops_log=str
Igual que escribir_bw_log, pero escribe IOPS. Si no se proporciona un nombre de archivo con esta opción,
se utiliza el nombre de archivo predeterminado "jobname_type.x.log", donde x es el índice del
trabajo (1..N, donde N es el número de trabajos). Incluso si se proporciona el nombre del archivo, fio
aún agregue el tipo de registro. Si registros_por_trabajo es falso, entonces el nombre del archivo no
incluir el índice de puestos.

log_avg_mseg=int
De forma predeterminada, fio registrará una entrada en el registro de iops, latencia o bw para cada IO que
completa. Al escribir en el registro del disco, eso puede crecer rápidamente a un tamaño muy grande.
Talla. Establecer esta opción hace que fio promedie cada entrada de registro sobre el especificado
período de tiempo, reduciendo la resolución del registro. El valor predeterminado es 0.

registro_desplazamiento=bool
Si se establece, las opciones de iolog incluirán el desplazamiento de bytes para la entrada IO como
así como los demás valores de datos.

log_compresión=int
Si se establece, fio comprimirá los registros de E / S a medida que avanza, para mantener la memoria
huella más baja. Cuando un registro alcanza el tamaño especificado, ese trozo se elimina y
comprimido en el fondo. Dado que los registros de E / S son bastante comprimibles,
esto produce un buen ahorro de memoria para ejecuciones más largas. La desventaja es que el
La compresión consumirá algunos ciclos de CPU en segundo plano, por lo que puede afectar la ejecución.
Sin embargo, esto también es cierto si el registro termina consumiendo la mayor parte del sistema.
memoria. Así que elige tu veneno. Los registros de E / S se guardan normalmente al final de una ejecución, por
descomprimir los fragmentos y almacenarlos en el archivo de registro especificado. Esta característica
depende de la disponibilidad de zlib.

log_store_comprimido=bool
Si está configurado, y log_compression también está configurada, fio almacenará los archivos de registro en un
formato comprimido. Se pueden descomprimir con fio, utilizando el --inflar-log
parámetro de línea de comando. Los archivos se almacenarán con un .fz sufijo.

block_error_percentiles=bool
Si está configurado, registre errores en unidades del tamaño de bloque de recorte de escrituras y recortes y genere un
histograma de cuántos ajustes se necesitaron para llegar a errores y qué tipo de error fue
encontrado.

desactivar_lat=bool
Deshabilite las mediciones de los números de latencia total. Útil solo para reducir el
número de llamadas a obtener la hora del día(2), ya que eso afecta el rendimiento a niveles realmente altos.
Tasas de IOPS. Tenga en cuenta que para deshacerse realmente de una gran cantidad de estas llamadas,
La opción debe usarse con disable_slat y disable_bw también.

desactivar_clat=bool
Deshabilite las mediciones de los números de latencia de finalización. Ver desactivar_lat.

deshabilitar_slat=bool
Deshabilite las mediciones de los números de latencia de envío. Ver desactivar_lat.

deshabilitar_bw_medida=bool
Deshabilite las mediciones de los números de ancho de banda / rendimiento. Ver desactivar_lat.

bloqueomem=int
Fijar la cantidad especificada de memoria con mlock(2). Puede usarse para simular un
menor cantidad de memoria. La cantidad especificada es por trabajador.

ejecutivo_prerun=str
Antes de ejecutar el trabajo, ejecute el comando especificado con te(3).
La salida se redirige a un archivo llamado nombretrabajo.preejecución.txt

ejecutivo_postrun=str
Igual que ejecutivo_prerun, pero el comando se ejecuta después de que se completa el trabajo.
La salida se redirige a un archivo llamado nombretrabajo.postrun.txt

planificador=str
Intente cambiar el dispositivo que aloja el archivo al programador de E / S especificado.

disk_util=bool
Genere estadísticas de utilización del disco si la plataforma lo admite. Predeterminado: verdadero.

fuente de reloj=str
Utilice la fuente de reloj dada como base de sincronización. Las opciones admitidas son:

obtener la hora del día
obtener la hora del día(2)

reloj_gettime
reloj_gettime(2)

cpu Fuente de reloj de CPU interna

cpu es la fuente de reloj preferida si es confiable, ya que es muy rápida
(y fio tiene muchas llamadas de tiempo). Fio utilizará automáticamente esta fuente de reloj si
es compatible y se considera confiable en el sistema en el que se ejecuta, a menos que
se establece específicamente otra fuente de reloj. Para CPU x86 / x86-64, esto significa admitir
TSC invariante.

gtod_reducir=bool
Habilite todos los obtener la hora del día(2) reducción de opciones (disable_clat, disable_slat,
disable_bw) además de reducir un poco la precisión del tiempo de espera para reducir realmente el
obtener la hora del día(2) recuento de llamadas. Con esta opción habilitada, solo hacemos alrededor del 0.4% de la
gtod () llamadas que hubiéramos hecho si todo el tiempo estuviera habilitado.

gtod_cpu=int
A veces es más barato dedicar un solo hilo de ejecución a obtener el
tiempo actual. Fio (y las bases de datos, por ejemplo) son muy intensivos en
obtener la hora del día(2) llamadas. Con esta opción, puede reservar una CPU para hacer
nada más que registrar la hora actual en una ubicación de memoria compartida. Luego el otro
Los subprocesos / procesos que ejecutan cargas de trabajo de E / S solo necesitan copiar ese segmento, en lugar de
entrando al kernel con un obtener la hora del día(2) llamar. La CPU reservada para hacer estos
Las llamadas de tiempo se excluirán de otros usos. Fio lo borrará manualmente del
Máscara de CPU de otros trabajos.

ignorar_error=str
A veces desea ignorar algunos errores durante la prueba, en ese caso puede especificar
lista de errores para cada tipo de error.
ignore_error = READ_ERR_LIST, WRITE_ERR_LIST, VERIFY_ERR_LIST
Los errores para el tipo de error dado se separan con ':'. El error puede ser el símbolo ('ENOSPC',
'ENOMEM') o un número entero.
Ejemplo: ignore_error = EAGAIN, ENOSPC: 122.
Esta opción ignorará EAGAIN de READ, y ENOSPC y 122 (EDQUOT) de WRITE.

volcado de error=bool
Si se establece, volca todos los errores, incluso si no son fatales, es verdadero de forma predeterminada. Solo si está discapacitado
el error fatal será arrojado

perfiles=str
Seleccione una prueba de rendimiento incorporada específica.

cgrupo=str
Agregue trabajo a este grupo de control. Si no existe, se creará. El sistema
debe tener un punto de montaje cgroup blkio montado para que esto funcione. Si su sistema
no lo tiene montado, puede hacerlo con:

# montar -t cgroup -o blkio ninguno / cgroup

peso_grupo=int
Establezca el peso del cgroup en este valor. Consulte la documentación que viene con
el kernel, los valores permitidos están en el rango de 100..1000.

cgroup_nodelete=bool
Normalmente, fio eliminará los cgroups que ha creado una vez finalizado el trabajo. A
anular este comportamiento y dejar cgroups después de la finalización del trabajo, establezca
cgroup_nodelete = 1. Esto puede ser útil si se quiere inspeccionar varios archivos cgroup.
después de la finalización del trabajo. Predeterminado: falso

UID=int
En lugar de ejecutar como el usuario que invoca, establezca el ID de usuario en este valor antes de
hilo / proceso hace cualquier trabajo.

gid=int
Establecer ID de grupo, ver UID.

unidad_base=int
Unidad base para informes. Los valores permitidos son:

0 Usar detección automática (predeterminado).

8 Basado en bytes.

1 Basado en bits.

flujo_id=int
El ID del flujo. Si no se especifica, por defecto es un flujo global. Ver de tus señales.

de tus señales=int
Peso en control de flujo basado en fichas. Si se usa este valor, entonces hay un de tus señales
mostrador que se utiliza para regular la proporción de actividad entre dos o más
trabajos. fio intenta mantener este contador de flujo cerca de cero. El de tus señales soportes de parámetros
para saber cuánto se debe sumar o restar al contador de flujo en cada iteración de
el bucle de E / S principal. Es decir, si un trabajo tiene flujo = 8 y otro trabajo tiene flujo = -1, entonces
Habrá una proporción aproximada de 1: 8 en cuanto a cuánto se ejecuta uno frente al otro.

flujo_marca de agua=int
El valor máximo que puede alcanzar el valor absoluto del contador de flujo.
antes de que el trabajo debe esperar por un valor más bajo del contador.

fluir_dormir=int
El período de tiempo, en microsegundos, que debe esperar después de que se haya aplicado la marca de agua de flujo.
excedido antes de reintentar operaciones

clat_percentiles=bool
Habilite el informe de percentiles de latencias de finalización.

lista de percentiles=lista_flotante
Sobrescriba la lista predeterminada de percentiles para las latencias de finalización y el bloque
histograma de error. Cada número es un número flotante en el rango (0,100], y el
la longitud máxima de la lista es 20. Utilice ':' para separar los números. Por ejemplo,
--percentile_list = 99.5: 99.9 hará que fio informe los valores de finalización
latencia por debajo de la cual cayeron el 99.5% y el 99.9% de las latencias observadas, respectivamente.

motor parámetros Lista
Algunos parámetros solo son válidos cuando se utiliza un motor io específico. Estos se utilizan
de forma idéntica a los parámetros normales, con la salvedad de que cuando se utilizan en la línea de comandos,
debe venir después del ioengine.

(cpu) cpuload=int
Intente utilizar el porcentaje especificado de ciclos de CPU.

(cpu) cpuchunks=int
Divida la carga en ciclos del tiempo dado. En microsegundos.

(cpu) exit_on_io_done=bool
Detecta cuando se terminan los subprocesos de E / S, luego sal.

(libaio) usuario_reap_espacio
Normalmente, con el motor libaio en uso, fio usará la llamada al sistema io_getevents
para cosechar eventos recién devueltos. Con esta bandera encendida, se leerá el anillo AIO
directamente desde el espacio de usuario para cosechar eventos. El modo de cosecha solo está habilitado cuando
sondeo de un mínimo de 0 eventos (por ejemplo, cuando iodepth_batch_complete = 0).

(net, netsplice) nombre de host=str
El nombre de host o la dirección IP que se utilizará para las E / S basadas en TCP o UDP. Si el trabajo es un TCP
oyente o lector UDP, el nombre de host no se utiliza y debe omitirse a menos que sea un
dirección de multidifusión UDP válida.

(net, netsplice) puerto=int
El puerto TCP o UDP al que enlazar o conectarse. Si esto se usa con entumecidos para desovar
varias instancias del mismo tipo de trabajo, entonces este será el número de puerto inicial
ya que fio utilizará una variedad de puertos.

(net, netsplice) interfaz=str
La dirección IP de la interfaz de red utilizada para enviar o recibir multidifusión UDP
paquetes.

(red, empalme de red) ttl=int
Valor de tiempo de vida para paquetes de multidifusión UDP salientes. Predeterminado: 1

(red, empalme de red) nodelay=bool
Establezca TCP_NODELAY en conexiones TCP.

protocolo (net, netsplice)=str, proto=str
El protocolo de red que se utilizará. Los valores aceptados son:

tcp Protocolo de Control de Transmisión

tcpv6 Protocolo de control de transmisión V6

udp Protocolo de datagrama de usuario

udpv6 Protocolo de datagramas de usuario V6

UNIX Socket de dominio UNIX

Cuando el protocolo es TCP o UDP, también se debe dar el puerto, así como la
nombre de host si el trabajo es un escucha de TCP o un lector de UDP. Para sockets Unix, lo normal
Se debe utilizar la opción de nombre de archivo y el puerto no es válido.

(red, netsplice) escucha
Para conexiones de red TCP, dígale a fio que escuche las conexiones entrantes en lugar de
que iniciar una conexión saliente. El nombre de host debe omitirse si esta opción
se utiliza.

(red,ping pong)=bool
Normalmente, un escritor de red continuará escribiendo datos y un lector de red
solo consumirá paquetes. Si se establece pingpong = 1, un escritor enviará su
carga útil al lector, luego espere a que el lector envíe la misma carga útil de vuelta.
Esto permite a fio medir las latencias de la red. La sumisión y finalización
Luego, las latencias miden el tiempo local empleado en enviar o recibir, y la finalización
la latencia mide cuánto tiempo tardó el otro extremo en recibir y enviar de vuelta. Para
El tráfico de multidifusión UDP pingpong = 1 solo debe configurarse para un solo lector cuando
varios lectores están escuchando la misma dirección.

(red,tamaño de ventana)=int
Establezca el tamaño de búfer de socket deseado para la conexión.

(red,mss)=int
Establezca el tamaño de segmento máximo de TCP (TCP_MAXSEG).

(e4defrag, donorname)=str
El archivo se utilizará como donante de bloque (intercambiar extensiones entre archivos)

(e4defrag, en su lugar)=int
Configurar la estrategia de asignación de bloques de archivos de donantes
0 (predeterminado): Asignar previamente el archivo del donante en init

1: asignar espacio inmediatamente dentro del evento de desfragmentación y liberarlo inmediatamente después
evento

(rbd) rbdname=str
Especifica el nombre del RBD.

(rbd) piscina=str
Especifica el nombre del grupo de Ceph que contiene el RBD.

(rbd) nombre de cliente=str
Especifica el nombre de usuario (sin el prefijo 'cliente') utilizado para acceder a Ceph
racimo.

(mtd) skipbad=bool
Omitir operaciones contra bloques defectuosos conocidos.

SALIDA

Mientras corre, fio mostrará el estado de los trabajos creados. Por ejemplo:

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

Los caracteres del primer conjunto de corchetes indican el estado actual de cada hilo.
Los valores posibles son:

P Configuración pero no iniciada.
C Hilo creado.
I Inicializado, esperando.
R Corriendo, haciendo lecturas secuenciales.
r Corriendo, haciendo lecturas aleatorias.
W Ejecutando, haciendo escrituras secuenciales.
w Corriendo, haciendo escrituras aleatorias.
M Ejecutando, haciendo lecturas / escrituras secuenciales mixtas.
m Ejecutando, haciendo lecturas / escrituras aleatorias mixtas.
F Corriendo, actualmente esperando fsync(2).
V Ejecutando, verificando datos escritos.
E Salido, no cosechado por el hilo principal.
- Excitado, hilo cosechado.

El segundo conjunto de corchetes muestra el porcentaje de finalización estimado del grupo actual.
El tercer conjunto muestra la velocidad de E / S de lectura y escritura, respectivamente. Finalmente, la ejecución estimada
se muestra la hora del trabajo.

Cuándo fio completa (o es interrumpido por Ctrl-C), mostrará datos para cada hilo, cada
grupo de subprocesos y cada disco, en ese orden.

Las estadísticas por subproceso muestran primero el número de cliente de los subprocesos, el ID de grupo y el código de error. El
las cifras restantes son las siguientes:

io Número de megabytes de E / S realizados.

bw Tasa de datos promedio (ancho de banda).

enano Los hilos se ejecutan en tiempo.

lama Latencia de envío mínima, máxima, media y desviación estándar. Esto es
el tiempo que tardó en enviar la E / S.

ruido Latencia de finalización mínima, máxima, media y desviación estándar. Esta
es el tiempo entre la presentación y la finalización.

bw Ancho de banda mínimo, máximo, porcentaje del ancho de banda agregado recibido,
desviación estándar y promedio.

cpu Estadísticas de uso de CPU. Incluye tiempo del usuario y del sistema, número de contexto
los conmutadores por los que pasó este hilo y el número de fallos de página mayores y menores.

IO profundidades
Distribución de profundidades de E / S. Cada profundidad incluye todo lo que sea menor que (o
igual), pero mayor que la profundidad anterior.

IO emitido
Número de solicitudes de lectura / escritura emitidas y número de lectura / escritura corta
peticiones.

IO latencias
Distribución de latencias de finalización de E / S. Los números siguen lo mismo
patrón como IO profundidades.

Las estadísticas del grupo muestran:
io Número de megabytes de E / S realizadas.
agregado Ancho de banda agregado de subprocesos en el grupo.
min b Ancho de banda mínimo promedio de una sierra de hilo.
máximo Ancho de banda medio máximo de una sierra de hilo.
menta El tiempo de ejecución más corto de los subprocesos del grupo.
máximo Mayor tiempo de ejecución de subprocesos en el grupo.

Finalmente, las estadísticas del disco se imprimen con lecturas primero:
ios Número de E / S realizadas por todos los grupos.
unir Número de fusiones en el planificador de E / S.
garrapatas Número de tics que mantuvimos el disco ocupado.
cola_io
Tiempo total pasado en la cola del disco.
util Utilización del disco.

También es posible hacer que fio descargue la salida actual mientras se está ejecutando, sin
terminando el trabajo. Para hacer eso, envíe a fio el USR1 señal.

BREVE SALIDA

Si --mínimo / --append-conciso se dan las opciones, los resultados se imprimirán / adjuntarán
en un formato delimitado por punto y coma adecuado para uso con guiones. Una descripción del trabajo (si
siempre) sigue en una nueva línea. Tenga en cuenta que el primer número de la línea es la versión
número. Si la salida tiene que cambiarse por alguna razón, este número se incrementará
por 1 para indicar ese cambio. Los campos son:

breve versión, fio versión, nombre del trabajo, Identificación del grupo, error

Leer estado:
Total I / O (KB), ancho de banda (KB / s), IOPS, tiempo de ejecución (Sra)

Latencia de envío:
min máx, media, estándar desviación
Latencia de finalización:
min máx, media, estándar desviación
Percentiles de latencia de finalización (20 campos):
X percentil = usec
Latencia total:
min máx, media, estándar desviación
Ancho de Banda:
min máx, agregar porcentaje of total media, estándar desviación

Estado de escritura:
Total I / O (KB), ancho de banda (KB / s), IOPS, tiempo de ejecución (Sra)

Latencia de envío:
min máx, media, estándar desviación
Latencia de finalización:
min máx, media, estándar desviación
Percentiles de latencia de finalización (20 campos):
X percentil = usec
Latencia total:
min máx, media, estándar desviación
Ancho de Banda:
min máx, agregar porcentaje of total media, estándar desviación

Uso de CPU:
usuario, sistema, contexto interruptores, gran página fallas, menor de edad página fallas

Distribución de profundidad IO:
<= 1, 2, 4, 8, 16, 32, > = 64

Distribución de latencia IO:
Microsegundos:
<= 2, 4, 10, 20, 50, 100, 250, 500, 750, 1000
Milisegundos:
<= 2, 4, 10, 20, 50, 100, 250, 500, 750, 1000, 2000, > = 2000

Utilización del disco (1 por cada disco utilizado):
nombre, leer ios escribir ios leer fusiona, escribir fusiona, leer garrapatas escribir
garrapatas leer en fila tiempo, escribir en fila tiempo, disco utilización porcentaje

Información de error (depende de continue_on_error, desactivada por defecto):
total # errores, la primera error código

texto descripción (Si previsto in config - aparece on nueva línea)

CLIENTE / SERVIDOR

Normalmente, ejecutaría fio como una aplicación independiente en la máquina donde el IO
se debe generar carga de trabajo. Sin embargo, también es posible ejecutar el frontend y el backend
de fio por separado. Esto hace posible tener un servidor fio ejecutándose en la (s) máquina (s)
dónde debería ejecutarse la carga de trabajo de E / S, mientras se controla desde otra máquina.

Para iniciar el servidor, deberías hacer:

fio --servidor = argumentos

en esa máquina, donde args define lo que escucha fio. Los argumentos son de la forma
'tipo: nombre de host o IP: puerto'. 'tipo' es 'ip' (o ip4) para TCP / IP v4, 'ip6' para TCP / IP
v6, o 'sock' para un socket de dominio Unix local. 'nombre de host' es un nombre de host o una IP
dirección, y 'puerto' es el puerto para escuchar (solo válido para TCP / IP, no un socket local).
Algunos ejemplos:

1) fio - servidor

Inicie un servidor fio, escuchando en todas las interfaces en el puerto predeterminado (8765).

2) fio --server = ip: nombre de host, 4444

Inicie un servidor fio, escuchando en la IP que pertenece al nombre de host y en el puerto 4444.

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

Inicie un servidor fio, escuchando en IPv6 localhost :: 1 y en el puerto 4444.

4) fio --servidor =, 4444

Inicie un servidor fio, escuchando en todas las interfaces en el puerto 4444.

5) fio --server = 1.2.3.4

Inicie un servidor fio, escuchando IP 1.2.3.4 en el puerto predeterminado.

6) fio --server = calcetín: /tmp/fio.sock

Inicie un servidor fio, escuchando en el socket local /tmp/fio.sock.

Cuando se está ejecutando un servidor, puede conectarse a él desde un cliente. El cliente se ejecuta con:

fio --local-args --client = servidor --remote-args

donde --local-args son argumentos que son locales para el cliente donde se está ejecutando,
'servidor' es la cadena de conexión, y --remote-args y son enviados a la
servidor. La cadena 'servidor' sigue el mismo formato que en el lado del servidor, para
Permitir cadenas de IP / nombre de host / socket y puerto. También puede conectarse a varios clientes,
para hacer eso podrías ejecutar:

fio --cliente = servidor2 --cliente = servidor2

Si el archivo de trabajo se encuentra en el servidor fio, puede decirle al servidor que cargue un archivo local.
archivo también. Esto se hace usando --remote-config:

fio --client = server --remote-config /path/to/file.fio

Luego, fio abrirá este archivo de trabajo local (al servidor) en lugar de pasar uno de
el cliente.

Si tiene muchos servidores (ejemplo: 100 máquinas virtuales / contenedores), puede ingresar un nombre de ruta de un archivo
que contiene direcciones IP / nombres de host como valor de parámetro para la opción --client. Por ejemplo,
aquí hay un ejemplo de archivo "host.list" que contiene 2 nombres de host:

host1.su.dns.dominio
host2.su.dns.dominio

El comando fio sería entonces:

fio --client = host.list

En este modo, no puede ingresar parámetros específicos del servidor o archivos de trabajo, y todos los servidores
recibir el mismo archivo de trabajo.

Para habilitar fio --client se ejecuta utilizando un sistema de archivos compartido desde múltiples hosts,
fio --client ahora antepone la dirección IP del servidor al nombre del archivo. Por ejemplo, si
fio está usando el directorio / mnt / nfs / fio y está escribiendo el nombre de archivo fileio.tmp, con un --client
archivo de host que contiene dos nombres de host h1 y h2 con direcciones IP 192.168.10.120 y
192.168.10.121, luego fio creará dos archivos:

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

AUTORES

fio fue escrito por Jens Axboe[email protected]>, ahora Jens Axboe[email protected]>.
Esta página de manual fue escrita por Aaron Carroll[email protected]> basado en documentación
por Jens Axboe.

PRESENTACIÓN DE INFORMES LOCO

Informar errores al fio lista de correo[email protected]>. Ver README.

Use fio en línea usando los servicios de onworks.net