Aio что это за программа

All-In-One Toolbox: очистить

Более 10 миллионов загрузок
Приложение позволит вам не только избавиться от ненужных файлов, но и оптимизирует использование памяти вашего гаджета. Такая очистка способствует повышению скорости работы устройства и не только, с помощью представленного программного продукта вы можете увидеть подробную информацию об устройстве, о состоянии памяти на нем и о ее загруженности. Для пользователя также будут доступны быстрые настройки и еще много другого.

Приложение All-In-One Toolbox не требует дополнительных программ для эффективной работы и с легкостью заменит несколько схожих за функциями, но менее функциональных сервисов. Программа объединяет в себе множество системных утилит, что позволит добиться максимально быстрой и эффективной работы вашего устройства и обезопасить его от вредоносных файлов.

Основные функции:
Очистка памяти устройства от ненужных файлов
Оптимизация хранения файлов
Мгновенное сканирование и очистка гаджета от ненужного мусора

Мультизагрузочная флешка с использованием AIO Boot

Очистка кэшей приложений
Проверка температуры телефона, предотвращение перегрева
Легкий доступ ко всем хранящимся на устройстве файлам
Удаление, перемещение и копирование приложений
Шифрование личных файлов

Последнее обновление
17 июл. 2022 г.

Безопасность данных

arrow_forward

Чтобы контролировать безопасность, нужно знать, как разработчики собирают ваши данные и передают их третьим лицам. Методы обеспечения безопасности и конфиденциальности могут зависеть от того, как вы используете приложение, а также от вашего региона и возраста. Информация ниже предоставлена разработчиком и в будущем может измениться.

Источник: play.google.com

AIO файл: Что это такое?

Файлы AIO связаны с один типом (-ами) файлов, и их можно просматривать с помощью IBM APL, разработанного IBM. В целом, этот формат связан с один существующим (-и) прикладным (-и) программным (-и) средством (-ами). Обычно они имеют формат APL Transfer Format File. Основную часть этих фацлов классифицируют, как Developer Files.

Файлы AIO были обнаружены на платформах Windows, Linux и Solaris. Они подходят для настольных ПК (и мобильных устройств). Рейтинг популярности данных файлов составляет «Низкий», что означает, что они не очень распространены.

Однако следует учитывать, что существует намного больше информации, которую следует знать о файлах AIO; далее представлены лишь савые важные детали в отношении этих типов файлов. Если у вас возникли проблемы с открытием этих файлов, или вы хотите получить более подробную информацию, ознакомьтесь с подробной информацией, представленной ниже.

Источник: www.solvusoft.com

Скачать All in One Runtimes v.2.5.0 для Windows

All in One Runtimes — это программное обеспечение, устанавливающее самые необходимые системные компоненты, библиотеки, в операционной системе Windows. Благодаря этому вы можете значительно сэкономить время, которое обычно тратится на поиск отдельного компонента через поисковые системы. Программа “All in One Runtimes” полностью автоматизирует процесс.

1 AIO Boot для создания мультизагрузочных флешек

С ее помощью вы сможете установить в несколько кликов такие компоненты как .NET Framework, среды выполнения Visual C++ Runtimes 2005, 2008, 2012, 2013, 2015, 2017, Adobe Flash Player, Microsoft Silverlight, Shockwave Player, Java, Visual J-Sharp и другие.

После первого запуска утилита просканирует систему на наличии установленных библиотек и компонентов, и предложит скачать необходимые для вашего компьютера.

Кроме того, вы сможете выбрать какие вам не требуются и снять галочки для того что бы не устанавливать их.

Есть один большой минус, программу разработали в германии, и после запуска кнопки и некоторые элементы интерфейса на немецком языке, при этом во всяком случае при тестировании возникли проблемы с кодировкой, и вместо кнопок мы увидели “кракозябры”.

В целом интерфейс интуитивно понятен, и разобраться в нем не сложно даже учитываю такой неприятный момент. В случае проблем вы всегда можете написать в комментариях и мы постараемся помочь.

Источник: softportal.pro

AIO Boot Creator: как создать мультизагрузочный LiveUSB для Legacy и UEFI

Привет, друзья. Этой публикацией пополним копилку знаний нашего сайта об инструментах создания мультизагрузочного носителя. Ниже рассмотрим, как работать с бесплатной утилитой AIO Boot Creator. Эта утилита создаёт из флешки или внешнего жёсткого диска мультизагрузочный носитель AIOBoot, способный загружаться на компьютерах как со старой BIOS Legacy, так и с UEFI.

Плюс к этому, создавая носитель с совместимой с UEFI файловой системой FAT32, AIO Boot Creator своими средствами решает вопрос с записью на носитель файлов весом больше 4 Гб. Но более того: эта утилита реализует на носителе свою загрузочную среду, в которую мы можем добавлять какое-угодно самозагружаемое ПО и удалять его за ненадобности без перезаписи всего носителя. И также мы сможем загружаться просто с загрузочных образов, добавленных на носитель или даже находящихся на внутреннем жёстком диске компьютера. Давайте рассмотрим возможности AIO Boot Creator.

AIO Boot Creator: как создать мультизагрузочный LiveUSB для Legacy и UEFI

AIO Boot Creator: что такое

Итак, друзья, что такое AIO Boot Creator? Это утилита, реализующая на внешнем носителе мультизагрузочный LiveUSB с названием AIOBoot — среду с загрузчиком Grub, которая может запускаться и на Legacy-, и на UEFI-компьютерах. Но это только загрузочная среда, содержимое LiveUSB мы определяем сами.

AIO Boot Creator, по сути, являет собой конструктор нашего собственного LiveUSB, который мы можем комплектовать установочными процессами операционных систем Windows, Linux и даже Mac OS. Так, загрузочная среда AIOBoot в числе пунктов загрузки предусматривает запуск загрузчика Clover. Собственный LiveUSB мы также можем комплектовать различными антивирусными и аварийными LiveDisk’ами на базе Linux и WinPE. При этом мы можем интегрировать в LiveUSB дистрибутив самозагружаемого ПО, а можем просто запускать его с файлов образов ISO, WIM и VHD, находящихся на внешнем носителе или даже на внутреннем жёстком диске компьютера.

Вот так, друзья, выглядит загрузочная среда AIOBoot: в меню загрузчика Grub у нас будет множество пунктов запуска — интегрированное самозагружаемое ПО, установка Windows, запуск с образов, запуск с жёсткого диска, прочие пункты загрузки.

Такой LiveUSB, кстати, можно использовать в качестве мультизагрузчика компьютера. В числе пунктов загрузки будет rEFInd – загрузочная утилита, являющая собой загрузочное меню с графическим интерфейсом для выбора запуска операционных систем Windows, Linux и Mac.

Утилита AIO Boot Creator устанавливается непосредственно на флешку или внешний жёсткий диск, из которых мы хотим сделать мультизагрузочный LiveUSB. А устанавливается с помощью утилиты AIO Boot Extractor, её можно скачать на официальном сайте проекта AIOBoot — Aioboot.Com . Запускаем AIO Boot Extractor. Кстати, если у вас фильтр SmartScreen заблокирует запуск этой утилиты, жмите «Подробнее», затем – «Выполнить в любом случае».

Запускаем и приступаем к созданию мультизагрузочного LiveUSB.

Создание мультизагрузочного LiveUSB AIOBoot

Что делает AIO Boot Extractor? Эта утилита подготавливает наш носитель, чтобы он превратился в мультизагрузочный LiveUSB AIOBoot. Она копирует на флешку или внешний диск файлы утилиты AIO Boot Creator и устанавливает загрузчик Grub. В окошке AIO Boot Extractor выбираем русский язык, указываем нужный носитель информации, если их несколько. И форматируем его в FAT32.

Форматированный в FAT32 наш мультизагрузочный носитель будет совместим и с Legacy, и с UEFI.

Далее устанавливаем загрузчик Grub. Пункт «Автоматическая установка загрузчика» активен по умолчанию, мы просто жмём «Ок» и ещё раз подтверждаем форматирование.

Ожидаем, пока выполнятся все необходимые операции – форматирование, установка загрузчика, копирование файлов AIO Boot Creator.

И перед нами появится утилита AIO Boot Creator. Впредь мы её сможем запускать с нашего мультизагрузочного LiveUSB, в корне носителя будет файл запуска утилиты. Первым делом зайдём в её настройки.

И установим для среды загрузчика Grub русский язык.

Далее нужно добавить в наш LiveUSB самозагружаемое ПО – дистрибутив процессов установки операционных систем и LiveDisk’ов.

Интеграция дистрибутива в AIOBoot

Чтобы добавить в LiveUSB дистрибутив, идём в раздел «Интеграция». Здесь выбираем сначала пакет, т.е. тип дистрибутива, например, Windows.

Потом выбираем вид дистрибутива этого типа, в нашем случае это будут установочные процессы Windows и LiveDisk’и на базе WinPE. Некоторые известные LiveDisk’и уже предусмотрены в этом меню, например, WinPE 10-8 Sergei Strelec, который я хочу добавить.

Далее добавляем ISO-образ этого WinPE. И жмём «Ок».

Ожидаем, пока образ запишется на носитель.

И далее можем добавлять другие дистрибутивы. Я добавлю ещё, например, MSDaRT и WinPE AOMEI PE Builder. Тип я в обоих случаях выбираю «Windows». Далее выбираю вид: для MSDaRT предусмотрен вид этого LiveDisk’а, а вот для AOMEI PE Builder я выбираю «WinPE 7/8.1/10».

При добавлении неизвестных утилите AIO Boot Creator сборок WnPE она предложит нам ввести для них своё название, как нам будет удобно, чтобы эти сборки значились в загрузочном меню.

И можем ещё добавить что-то, например, установку Windows 10. Для добавления установочных процессов Windows используем тип дистрибутива «Windows», вид – «Windows 7/8.1/10/Server Setup».

При добавлении установочных образов Windows мы также можем указать свои наименования, как они будут значиться в загрузочном меню.

И что примечательно, друзья, если в составе дистрибутива Windows будет файл с весом больше 4 Гб, который не сможет быть записан на файловую систему FAT32 из-за её ограничений, нам будет предложена разбивка этого файла на части.

Интегрированные дистрибутивы значатся в загрузочном меню AIOBoot. Например, WinPE 10-8 Sergei Strelec в нём идёт вообще отдельным пунктом. А для запуска процесса установки Windows 10 и двух добавленных нами WinPE нужно выбрать пункт «WinPE VHD», если нам нужно загрузиться с образа LiveDisk’а.

Далее в обоих случаях выбираем наш LiveUSB, он будет отмечен как «AIOBoot». Потом выбираем папку, где хранятся образы, потом – сам образ.

Дистрибутив с образов, хранящихся на внутреннем жёстком диске, запускается таким же образом, только при выборе диска мы, соответственно, выбираем раздел внутреннего диска и далее следуем к папке хранения образов.

Тестирование LiveUSB

Друзья, AIO Boot Creator – утилита, содержащая в себе иной бесплатный софт, который может нам пригодиться в работе с мультизагрузочным LiveUSB. В главной вкладке утилиты жмём «Инструменты».

Из известных программ здесь есть Bootice, архиватор 7-Zip, и также есть эмулятор Qemu — примитивный гипервизор для тестирования созданного мультизагрузочного носителя AIOBoot. С его помощью мы сможем проверить загрузку нашего LiveUSB в режиме Legacy и запустить 32-битное ПО.

Друзья, если вы хотите протестировать флешку в режиме UEFI на виртуальной машине, смотрите вторую часть статьи «Как протестировать загрузочную флешку на предмет её работоспособности в среде Windows».

LiveUSB с отдельным разделом с файловой системой NTFS или exFAT

Дабы быть совместимым и с Legacy, и с UEFI, носитель AIOBoot изначально форматируется в файловую систему FAT32, ограниченную хранением файлов весом до 4 Гб. Если нам нужно добавить в наш LiveUSB дистрибутив, в составе которого имеется файл более 4 Гб, AIO Boot Creator имеет решение в виде разбивки файла на части. Но это решение только для интегрированного дистрибутива. Оно не работает для обычных образов.

Для таковых нам нужно создать на флешке или внешнем диске отдельный раздел с файловой системой NTFS или exFAT, которые смогут хранить файлы весом более 4 Гб. При этом наш LiveUSB будет загружаться с раздела с FAT32, на котором находится загрузочная среда AIOBoot, в любом режиме – и в UEFI, и в Legacy. Этот раздел нужно просто ужать, чтобы создать второй раздел с NTFS или exFAT. Если у вас уже создан LiveUSB AIOBoot, можете сделать переразметку носителя с помощью любой программы по работе с дисковым пространством. У нас, кстати, есть на сайте мануал «Как создать на флешке с FAT32 раздел с NTFS программой Paragon Hard Disk Manager 17».

Но если вы ещё не создали LiveUSB AIOBoot, можете воспользоваться возможностью разбивки носителя на два раздела, предлагаемой утилитой AIO Boot Extractor. Вместо форматирования флешки или диска в FAT32, как мы выполняли в начале, мы жмём «Авторазбиение». Выбираем пункт «FAT32 https://remontcompa.ru/programmnyy-funkcional/2121-aio-boot-creator-kak-sozdat-multizagruzochnyj-liveusb-dlja-legacy-i-uefi.html» target=»_blank»]remontcompa.ru[/mask_link]

io_submit: альтернатива epoll, о которой вы никогда не слышали

Недавно внимание автора привлекла статья на LWN о новом интерфейсе ядра для опроса (polling). В ней обсуждается новый механизм опроса в Linux AIO API (интерфейс для асинхронной работы с файлами), который добавили в ядро версии 4.18. Идея довольно интересная: автор патча предлагает использовать Linux AIO API для работы с сетью.

Но постойте! Ведь Linux AIO был создан для работы с асинхронным вводом-выводом с диска / на диск! Файлы на диске — это не то же самое, что сетевые соединения. Возможно ли вообще использовать Linux AIO API для работы с сетью?

Оказывается, да, возможно! В этой статье объясняется, как использовать сильные стороны Linux AIO API для создания более быстрых и лучших сетевых серверов.

Но давайте начнём с разъяснения, что представляет собой Linux AIO.

Введение в Linux AIO

Linux AIO предоставляет интерфейс асинхронного ввода-вывода с диска / на диск для пользовательского ПО.

Исторически на Linux все дисковые операции блокировались. Если вы вызываете open() , read() , write() или fsync() , то поток останавливается до тех пор, пока метаданные не появятся в дисковом кеше. Обычно это не вызывает проблем. Если у вас не много операций ввода-вывода и достаточно памяти, системные вызовы постепенно заполнят кеш, и всё будет работать достаточно быстро.

Производительность операций ввода-вывода уменьшается, когда их количество достаточно велико, например в случаях с базами данных и прокси-серверами. Для подобных приложений неприемлемо останавливать весь процесс ради ожидания одного системного вызова read() .

Для решения этой проблемы приложения могут использовать три способа:

1. Использовать пулы потоков и вызывать блокирующие функции в отдельных потоках. Именно так работает POSIX AIO в glibc (не путайте его с Linux AIO). Подробные сведения можно получить в документации IBM. Именно так мы решили проблему в Cloudflare: для вызова read() и open() мы используем пул потоков.
2. Прогревать дисковый кеш с помощью posix_fadvise(2) и надеяться на лучшее.
3. Использовать Linux AIO в сочетании с файловой системой XFS, открывая файлы с флагом O_DIRECT и избегая недокументированных проблем.

«У интерфейса асинхронного ввода-вывода в Linux много критиков и мало сторонников, но большинство людей ожидает от него хотя бы асинхронности. На деле же операция AIO может блокироваться в ядре по целому ряду причин в ситуациях, когда вызывающий поток не может себе этого позволить».

Теперь, когда мы знаем о слабых сторонах Linux AIO API, давайте рассмотрим его сильные стороны.

Простая программа с использованием Linux AIO

Для того чтобы использовать Linux AIO, вам сначала придётся самостоятельно определить все пять необходимых системных вызовов — glibc их не предоставляет.

1. Сначала нужно вызвать io_setup() для инициализации структуры aio_context . Ядро вернёт нам непрозрачный (opaque) указатель на структуру.
2. После этого можно вызвать io_submit() , чтобы добавить в очередь на обработку вектор «контрольных блоков ввода-вывода» в виде структуры struct iocb.
3. Теперь, наконец, мы можем вызвать io_getevents() и ждать от неё ответа в виде вектора структур struct io_event — результатов работы каждого из блоков iocb.

IOCB_CMD_PREAD = 0, IOCB_CMD_PWRITE = 1, IOCB_CMD_FSYNC = 2, IOCB_CMD_FDSYNC = 3, IOCB_CMD_POLL = 5, /* from 4.18 */ IOCB_CMD_NOOP = 6, IOCB_CMD_PREADV = 7, IOCB_CMD_PWRITEV = 8,

Структура iocb , которая передаётся в функцию io_submit , достаточно крупная и предназначена для работы с диском. Вот её упрощённая версия:

struct iocb < __u64 data; /* user data */ . __u16 aio_lio_opcode; /* see IOCB_CMD_ above */ . __u32 aio_fildes; /* file descriptor */ __u64 aio_buf; /* pointer to buffer */ __u64 aio_nbytes; /* buffer size */ . >

Полная структура io_event , которую возвращает io_getevents :

struct io_event < __u64 data; /* user data */ __u64 obj; /* pointer to request iocb */ __s64 res; /* result code for this event */ __s64 res2; /* secondary result */ >;

Пример. Простая программа, которая читает файл /etc/passwd с помощью Linux AIO API:

fd = open(«/etc/passwd», O_RDONLY); aio_context_t ctx = 0; r = io_setup(128, char buf[4096]; struct iocb cb = ; struct iocb *list_of_iocb[1] = ; r = io_submit(ctx, 1, list_of_iocb); struct io_event events[1] = >; r = io_getevents(ctx, 1, 1, events, NULL); bytes_read = events[0].res; printf(«read %lld bytes from /etc/passwdn», bytes_read);

Полные исходники, конечно, доступны на GitHub. Вот вывод strace этой программы:

openat(AT_FDCWD, «/etc/passwd», O_RDONLY) io_setup(128, [0x7f4fd60ea000]) io_submit(0x7f4fd60ea000, 1, []) io_getevents(0x7f4fd60ea000, 1, 1, [], NULL)

Всё прошло хорошо, но чтение с диска не было асинхронным: вызов io_submit заблокировался и выполнил всю работу, функция io_getevents выполнилась мгновенно. Мы могли попробовать читать асинхронно, но это требует флага O_DIRECT, с которым дисковые операции идут в обход кеша.

Давайте лучше проиллюстрируем то, как io_submit блокируется на обычных файлах. Вот аналогичный пример, который показывает вывод strace в результате чтения блока объёмом 1 Гб из /dev/zero :

io_submit(0x7fe1e800a000, 1, []) = 1 io_getevents(0x7fe1e800a000, 1, 1, [], NULL) = 1

Ядро потратило 738 мс на вызов io_submit и только 15 нс — на io_getevents . Подобным образом оно ведёт себя и с сетевыми соединениями — вся работа делается io_submit .

Фото Helix84 CC/BY-SA/3.0

Linux AIO и сеть

Реализация io_submit достаточно консервативна: если переданный дескриптор файла не был открыт с флагом O_DIRECT, то функция просто блокируется и выполняет указанное действие. В случае с сетевыми соединениями это означает, что:

• для блокирующих соединений IOCV_CMD_PREAD будет ждать ответного пакета;
• для неблокирующих соединений IOCB_CMD_PREAD вернёт код -11 (EAGAIN).

Важно отметить, что запросы iocb выполняются ядром последовательно.

Несмотря на то, что Linux AIO не поможет нам с асинхронными операциями, его можно использовать для объединения системных вызовов в пакеты (batches).

Если веб-серверу нужно отправить и получить данные из сотен сетевых соединений, то использование io_submit может оказаться отличной идеей, поскольку позволит избежать сотен вызовов send и recv. Это улучшит производительность — переход из пользовательского пространства в ядро и обратно не бесплатен, особенно после введения мер по борьбе со Spectre и Meltdown.

Один буфер	Несколько буферов
Один файловый дескриптор	read()	readv()
Несколько файловых дескрипторов	io_submit + IOCB_CMD_PREAD	io_submit + IOCB_CMD_PREADV

Для иллюстрации группировки системных вызовов в пакеты с помощью io_submit давайте напишем небольшую программу, которая пересылает данные из одного TCP-соединения в другое. В простейшей форме (без Linux AIO) она выглядит примерно так:

while True: d = sd1.read(4096) sd2.write(d)

Тот же функционал мы можем выразить через Linux AIO. Код в этом случае будет таким:

struct iocb cb[2] = , >; struct iocb *list_of_iocb[2] = ; while(1) < r = io_submit(ctx, 2, list_of_iocb); struct io_event events[2] = <>; r = io_getevents(ctx, 2, 2, events, NULL); cb[0].aio_nbytes = events[1].res; >

Этот код добавляет два задания в io_submit : сначала запрос на запись в sd2 , а потом запрос на чтение из sd1. После выполнения чтения код исправляет размер буфера записи и повторяет цикл сначала. Есть одна хитрость: первый раз запись происходит с буфером размера 0. Это необходимо потому, что у нас есть возможность объединить write + read в одном вызове io_submit (но не read + write).

Быстрее ли этот код, чем обычные read() / write() ? Пока нет. Обе версии используют два системных вызова: read + write и io_submit + io_getevents. Но, к счастью, код можно улучшить.

Избавляемся от io_getevents

Во время выполнения io_setup() ядро выделяет несколько страниц памяти для процесса. Вот как этот блок памяти выглядит в /proc//maps:

marek:~$ cat /proc/`pidof -s aio_passwd`/maps . 7f7db8f60000-7f7db8f63000 rw-s 00000000 00:12 2314562 /[aio] (deleted) .

Блок памяти [aio] (12 Кб в данном случае) был выделен io_setup . Он используется для кольцевого буфера, где хранятся события. В большинстве случаев нет причин для вызова io_getevents — данные о завершении событий можно получить из кольцевого буфера без необходимости перехода в режим ядра. Вот исправленная версия кода:

int io_getevents(aio_context_t ctx, long min_nr, long max_nr, struct io_event *events, struct timespec *timeout) < int i = 0; struct aio_ring *ring = (struct aio_ring*)ctx; if (ring == NULL || ring->magic != AIO_RING_MAGIC) < goto do_syscall; >while (i < max_nr) < unsigned head = ring->head; if (head == ring->tail) < /* There are no more completions */ break; >else < /* There is another completion to reap */ events[i] = ring->events[head]; read_barrier(); ring->head = (head + 1) % ring->nr; i++; > > if (i == 0 timeout != NULL timeout->tv_sec == 0 timeout->tv_nsec == 0) < /* Requested non blocking operation. */ return 0; >if (i i >= min_nr) < return i; >do_syscall: return syscall(__NR_io_getevents, ctx, min_nr-i, max_nr-i, >

Полная версия кода доступна на GitHub. Интерфейс этого кольцевого буфера плохо документирован, автор адаптировал код из проекта axboe/fio.

После этого изменения наша версия кода с использованием Linux AIO требует только одного системного вызова в цикле, что делает её чуть быстрее, чем оригинальный код с использованием read + write.

Фото Train Photos CC/BY-SA/2.0

Альтернатива epoll

С добавлением IOCB_CMD_POLL в ядро версии 4.18 стало возможным использование io_submit в качестве замены select/poll/epoll. Например, этот код будет ожидать данных от сетевого соединения:

struct iocb cb = ; struct iocb *list_of_iocb[1] = ; r = io_submit(ctx, 1, list_of_iocb); r = io_getevents(ctx, 1, 1, events, NULL);

Полный код. Вот его вывод strace:

io_submit(0x7fe44bddd000, 1, []) = 1 io_getevents(0x7fe44bddd000, 1, 1, [], NULL) = 1

Как видите, в этот раз асинхронность сработала: io_submit выполнилась мгновенно, а io_getevents заблокировалась на одну секунду в ожидании данных. Это можно использовать вместо системного вызова epoll_wait() .

Более того, работа с epoll обычно требует использования системных вызовов epoll_ctl. А разработчики приложений стараются избегать частых вызовов этой функции — чтобы понять причины, достаточно прочитать в мануале о флагах EPOLLONESHOT и EPOLLET. Используя io_submit для опроса соединений, можно избежать этих сложностей и дополнительных системных вызовов. Просто добавьте соединения в вектор iocb, вызовите io_submit один раз и ожидайте выполнения. Всё очень просто.

Резюме

В этом посте мы рассмотрели Linux AIO API. Этот API изначально задумывался для работы с диском, но он работает также и с сетевыми соединениями. Однако, в отличие от обычных вызовов read() + write(), использование io_submit позволяет группировать системные вызовы и таким образом увеличивать производительность.

Начиная с ядра версии 4.18 io_submit и io_getevents в случае с сетевыми соединениями могут быть использованы для событий вида POLLIN и POLLOUT. Это является альтернативой epoll() .

Могу себе представить сетевой сервис, который использует только io_submit и io_getevents вместо стандартного набора read, write, epoll_ctl и epoll_wait. В этом случае группировка системных вызовов в io_submit может дать большое преимущество, такой сервер был бы значительно быстрее.

К сожалению, даже после недавних улучшений Linux AIO API дискуссия о его полезности продолжается. Хорошо известно, что Линус его ненавидит:

«AIO — это ужасный пример дизайна «на коленке», где основное оправдание: «другие, менее одарённые люди придумали это, поэтому мы вынуждены соблюдать совместимость ради того, чтобы разработчики баз данных (которые редко обладают вкусом) могли использовать это». Но AIO всегда был очень-очень кривым».

Было предпринято несколько попыток создать лучший интерфейс для группировки вызовов и асинхронности, однако им не хватило общего видения. Например, недавнее добавление sendto(MSG_ZEROCOPY) позволяет вести действительно асинхронную передачу данных, но не предусматривает группировки. io_submit предусматривает группировку, но не асинхронность. Ещё хуже — в Linux на данный момент есть три способа доставки асинхронных событий: сигналы, io_getevents и MSG_ERRQUEUE.

В любом случае, отлично, что появляются новые способы ускорить работу сетевых сервисов.

• Блог компании Badoo
• Высокая производительность
• Системное программирование
• C
• Разработка под Linux

Источник: habr.com