Como o benchmark da FIO define IOdepth?

Question

OBSERVAÇÃO: Minha pergunta decorre desse outro U & LQ - O que exatamente é o iodepth in fio?

Eu quero saber como internamente o FIO define a profundidade de E / S. Ou seja, um dos parâmetros que enviamos para a FIO quando a executamos é "IOdepth" ( --iodepth= ). Como a FIO controla internamente esse parâmetro com o sistema operacional subjacente?

Aqui está um exemplo do comando que usamos para executar o benchmark da FIO:

$ sudo fio --filename=/dev/nvme0n1 --direct=1 --rw=randwrite --refill_buffers \
    --norandommap --randrepeat=0 --ioengine=libaio --bs=8K --iodepth=72 --numjobs=256 \
    --time_based --runtime=600 --allow_mounted_write=1 --group_reporting --name=benchtest
benchtest: (g=0): rw=randwrite, bs=8K-8K/8K-8K/8K-8K, ioengine=libaio, iodepth=72

Como neste exemplo, o valor de "iodepth" pode ser alterado. Assim, o fio está passando esse valor para o sistema operacional. Então, como a FIO faz isso?

Se você quiser que um problema real seja resolvido: se eu quiser escrever um programa de benchmark como fio, como eu controlaria a profundidade da fila IO?

    

Answer 1

fio is passing this value [depth] to the operating system

e

Accordingly, fio is passing this value to the operating system. So how does FIO do this?

Pode haver um equívoco aqui: o fio NÃO está passando diretamente um parâmetro de profundidade para o sistema operacional. Se possível, o fio tenta enviar E / S até o iodepth especificado usando um determinado ioengine. Se essa profundidade for atingida , então o fio aguardará que algumas E / S pendentes sejam concluídas antes de tentar enviar mais E / S ...

How does FIO benchmark set [io]depth?

Depende do ioengine, depende dos parâmetros de fio mencionados em exatamente o iodepth in fio? , profundidade da fila"> link e link . Sem pequenos exemplos fixos, há muito para explicar.

Chega um ponto em que não há mais nada a fazer além de ler e entender o código do fio em si ... O Fio tem um loop principal para enviar I / Os (veja link ):

static void do_io(struct thread_data *td, uint64_t *bytes_done)
{
    [...]
    while ((td->o.read_iolog_file && !flist_empty(&td->io_log_list)) ||
        (!flist_empty(&td->trim_list)) || !io_issue_bytes_exceeded(td) ||
        td->o.time_based) {
        [...]
        } else {
            ret = io_u_submit(td, io_u);

            if (should_check_rate(td))
                td->rate_next_io_time[ddir] = usec_for_io(td, ddir);

            if (io_queue_event(td, io_u, &ret, ddir, &bytes_issued, 0, &comp_time))
                break;

            /*
             * See if we need to complete some commands. Note that
             * we can get BUSY even without IO queued, if the
             * system is resource starved.
             */
reap:
            full = queue_full(td) ||
                (ret == FIO_Q_BUSY && td->cur_depth);
            if (full || io_in_polling(td))
                ret = wait_for_completions(td, &comp_time);
        }
        [...]
    }
    [...]
}

A rotina de filas do ioengine é chamada por uma cadeia de chamadas de io_u_submit() . Assumindo que a ioengina é assíncrona, ela pode optar por "enfileirar" as E / Ss no fio e, posteriormente, enviá-las para baixo de uma só vez (geralmente como resultado de sua função getevents() ser chamada de wait_for_completions() chain de chamada). No entanto, deixaremos o rastreamento do código do fio como um exercício para o leitor.

if I want to write a benchmark program like fio, how would I control the IO queue depth?

Você precisaria imitar um dos ioengines (assíncronos) do fio e ter um loop de eventos que fosse capaz de (assincronamente) enviar E / Ss E verificar sua conclusão. Uma vez que você tivesse tal coisa, a idéia de que você se submete a uma determinada profundidade seria fácil - se em algum momento você tiver uma E / S incomparável que corresponda (ou exceda se você não estiver verificando um por um) a profundidade escolhida então você precisa esperar que algo seja concluído antes de enviar mais.

Você pode encontrar aio- stress.c no Linux Test Project mais fácil de entender / modificar do que se você está fazendo uma referência de brinquedo.