Я пишу библиотеку, которая использует системные вызовы асинхронного ввода-вывода Linux и хотела бы знать, почему функция io_submit демонстрирует плохое масштабирование файловой системы ext4. Если возможно, что я могу сделать, чтобы получить io_submit, чтобы не блокировать большие размеры запросов ввода-вывода? Я уже делаю следующее (как описано here):Linux AIO: Плохое масштабирование
- Использование
O_DIRECT. - Совместите буфер ввода-вывода с 512-байтной границей.
- Установите размер буфера на кратное размеру страницы.
Для того, чтобы наблюдать, как долго ядро проводит в io_submit, я провел тест, в котором я создал один тестовый Gb файл, используя dd и /dev/urandom, и несколько раз уронил системный кэш (sync; echo 1 > /proc/sys/vm/drop_caches) и читать все более крупные части файла. На каждой итерации я печатал время, отсчитываемое io_submit, и время, ожидаемое для завершения запроса на чтение. Я провел следующий эксперимент в системе x86-64 под управлением Arch Linux с версией ядра 3.11. Машина имеет SSD и процессор Core i7. На первом графике отображается количество прочитанных страниц относительно времени ожидания io_submit. Второй график отображает время ожидания ожидающего завершения запроса на чтение. Время измеряется в секундах.
Для сравнения, я создал подобный тест, который использует синхронную IO с помощью pread. Вот результаты:
кажется, что асинхронный IO работает как ожидается, до запросить размеры около 20000 страниц. После этого io_submit блоков. Эти наблюдения привели к следующим вопросам:
- Почему не время исполнения
io_submit? - В чем причина этого плохого масштабирования?
- Нужно ли разделить все запросы на чтение файловых систем ext4 на несколько запросов, каждый из которых составляет менее 20 000 страниц?
- Откуда это «магическое» значение 20 000? Если я запустил свою программу в другой системе Linux, как я могу определить самый большой размер запроса ввода-вывода для использования, не испытывая плохого поведения масштабирования?
Код, используемый для проверки асинхронного ввода-вывода, приведен ниже. Я могу добавить другие списки источников, если вы считаете их релевантными, но я попытался опубликовать только те детали, которые, как я думал, могут иметь значение.
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <chrono>
#include <iostream>
#include <memory>
#include <fcntl.h>
#include <stdio.h>
#include <time.h>
#include <unistd.h>
// For `__NR_*` system call definitions.
#include <sys/syscall.h>
#include <linux/aio_abi.h>
static int
io_setup(unsigned n, aio_context_t* c)
{
return syscall(__NR_io_setup, n, c);
}
static int
io_destroy(aio_context_t c)
{
return syscall(__NR_io_destroy, c);
}
static int
io_submit(aio_context_t c, long n, iocb** b)
{
return syscall(__NR_io_submit, c, n, b);
}
static int
io_getevents(aio_context_t c, long min, long max, io_event* e, timespec* t)
{
return syscall(__NR_io_getevents, c, min, max, e, t);
}
int main(int argc, char** argv)
{
using namespace std::chrono;
const auto n = 4096 * size_t(std::atoi(argv[1]));
// Initialize the file descriptor. If O_DIRECT is not used, the kernel
// will block on `io_submit` until the job finishes, because non-direct
// IO via the `aio` interface is not implemented (to my knowledge).
auto fd = ::open("dat/test.dat", O_RDONLY | O_DIRECT | O_NOATIME);
if (fd < 0) {
::perror("Error opening file");
return EXIT_FAILURE;
}
char* p;
auto r = ::posix_memalign((void**)&p, 512, n);
if (r != 0) {
std::cerr << "posix_memalign failed." << std::endl;
return EXIT_FAILURE;
}
auto del = [](char* p) { std::free(p); };
std::unique_ptr<char[], decltype(del)> buf{p, del};
// Initialize the IO context.
aio_context_t c{0};
r = io_setup(4, &c);
if (r < 0) {
::perror("Error invoking io_setup");
return EXIT_FAILURE;
}
// Setup I/O control block.
iocb b;
std::memset(&b, 0, sizeof(b));
b.aio_fildes = fd;
b.aio_lio_opcode = IOCB_CMD_PREAD;
// Command-specific options for `pread`.
b.aio_buf = (uint64_t)buf.get();
b.aio_offset = 0;
b.aio_nbytes = n;
iocb* bs[1] = {&b};
auto t1 = high_resolution_clock::now();
auto r = io_submit(c, 1, bs);
if (r != 1) {
if (r == -1) {
::perror("Error invoking io_submit");
}
else {
std::cerr << "Could not submit request." << std::endl;
}
return EXIT_FAILURE;
}
auto t2 = high_resolution_clock::now();
auto count = duration_cast<duration<double>>(t2 - t1).count();
// Print the wait time.
std::cout << count << " ";
io_event e[1];
t1 = high_resolution_clock::now();
r = io_getevents(c, 1, 1, e, NULL);
t2 = high_resolution_clock::now();
count = duration_cast<duration<double>>(t2 - t1).count();
// Print the read time.
std::cout << count << std::endl;
r = io_destroy(c);
if (r < 0) {
::perror("Error invoking io_destroy");
return EXIT_FAILURE;
}
}
Пробовал ли вы один и тот же тест со старой версией ядра? Например, 3.4? Я говорю только для того, чтобы убедиться, что это связано не с недавней, но еще не обнаруженной ошибкой в ядре. – Shahbaz
@Shahbaz Нет, еще нет - спасибо за предложение. Я сделаю это и снова отправлю сюда. –
Я не понимаю ваш график. Похоже, что AIO после 20K страниц * работает в постоянном режиме *, а не в блоках. –