Асинхронная модель ввода-вывода с точки
зрения приложений
В разд. Синхронный ввод-вывод,
обсуждая асинхронную модель драйвера, мы задались вопросом: должна ли
задача, сформировав запрос на ввод-вывод, дожидаться его завершения? Ведь
система, приняв запрос, передает его асинхронному драйверу, который инициирует
операцию на внешнем устройстве и освобождает процессор. Сама система не
ожидает завершения запроса. Так должна ли пользовательская задача ожидать
его?
Если было запрошено чтение данных, то ответ, на первый взгляд, очевиден:
должна. Ведь если данные запрошены, значит они сейчас будут нужны программе.
Однако можно выделить буфер для данных, запросить чтение, потом некоторое
время заниматься чем-то полезным, но не относящимся к запросу, и лишь
к точке, когда данные действительно будут нужны, спросить систему: а готовы
ли данные? Если готовы, то можно продолжать работу. Если нет, то придется
ждать (рис. 10.9).
Во многих приложениях, особенно интерактивных или работающих с другими
устройствами-источниками событий, асинхронное чтение оказывается единственно
приемлемым вариантом, поскольку оно позволяет задаче одновременно осуществлять
обмен с несколькими источниками данных и таким образом повысить пропускную
способность и/или улучшить время реакции на событие.
Рис. 10.9. Опережающее чтение
При записи, казалось бы, нет необходимости дожидаться
физическою вершения операции. При этом мы получаем режим, известный как
отложенная запись (lazy
write— "ленивая" запись, если переводить дослоцц0\ Однако
такой режим создает две специфические проблемы.
Во-первых, программа должна знать, когда ей можно использовать буфер данными
для других целей. Если система копирует записываемые данные из пользовательского
адресного пространства в системное, то эта же проблема возникает внутри
ядра; внутри ядра проблема решается использованием многобуферной схемы,
и все относительно просто. Однако копирование приводит к дополнительным
затратам времени и требует выделения памяти под буферы. Наиболее остро
эта проблема встает при работе с дисковыми и сетевыми устройствами, с
которыми система обменивается большими объемами данных (а сетевые устройства
еще и могут генерировать данные неожиданно). Проблема управления дисковыми
буферами подробнее обсуждается в разд. Дисковый
кэш.
В большинстве современных вычислительных систем общего назначения накладные
расходы, обусловленные буферизацией запросов, относительно невелики или
по крайней мере считаются приемлемыми. Но в системах реального времени
и/или встраиваемых контроллерах, где время и объем оперативной памяти
жестко ограничены, эти расходы оказываются серьезным фактором.
Если же вместо системных буферов используется отображение данных в системное
адресное пространство (системы с открытой памятью можно считать вырожденным
случаем такого отображения), то ситуация усложняется. Пользовательская
задача должна иметь возможность узнать о физическом окончании записи,
потому что только после этого буфер действительно свободен. Фактически,
программа должна самостоятельно реализовать много-буферную схему или искать
другие выходы.
Во-вторых, программа должна дождаться окончания операции, чтобы узнать,
успешно ли она закончилась. Часть ошибок, например, попытку записи на
устройство, физически не способное выполнить такую операцию, можно отловить
еще во время предобработки, однако аппаратные проблемы могут быть обнаружены
только на фазе исполнения запроса.
Многие системы, реализующие отложенную запись, при обнаружении аппаратной
ошибки просто устанавливают флаг ошибки в блоке управления устройством.
Программа предобработки, обнаружив этот флаг, отказывается исполнять следующий
запрос. Таким образом, прикладная программа считает ошибочно завершившийся
запрос успешно выполнившимся и обнаруживает ошибку лишь при одной из следующих
попыток записи, что не совсем правильно.
Иногда эту проблему можно игнорировать. Например, если программа встречает
одну ошибку при записи, то все исполнение программы считается неуспешным
и на этом заканчивается. Однако во многих случаях, например, задачах управления
промышленным или исследовательским оборудованием, программе необходимо
знать результат завершения операции, поэтому простая отложенная запись
оказывается совершенно неприемлемой.
Так или иначе, ОС, реализующая асинхронное исполнение запросов ввода-вывода,
должна иметь средства сообщить пользовательской программе о физическом
окончании операции и результате этой операции.
Синхронный и асинхронный ввод-вывод
в RSX-11 и VMS
Например, в системах RSX-11 и VAX/VMS фирмы DEC для синхронизации используется
флаг локального события (local event flag). Как говорилось в разд. Семафоры,
флаг события в этих системах представляет собой аналог двоичных семафоров
Дейкстры, но с ним также может быть ассоциирована процедура AST. Системный
вызов ввода-вывода в этих ОС называется QIC (Queue Input/Output [Request]
— установить в очередь запрос ввода-вывода) и имеет две формы: асинхронную
QIO и синхронную QIOW (Queue Input/Output and Wait— установить запрос
и ждать [завершения]). С точки зрения подсистемы ввода-вывода эти вызовы
ничем не отличаются, просто при запросе QIO ожидание конца запроса выполняется
пользовательской программой "вручную", а при QIOW выделение
флага события и ожидание его установки делается системными процедурами
пред- и постобработки.
В ряде систем реального времени, например, в OS-9 и RT-11, используются
аналогичные механизмы.
Напротив, большинство современных ОС общего назначения
не связываются с асинхронными вызовами и предоставляют прикладной программе
чисто синхронный интерфейс, тем самым вынуждая ее ожидать конца операции.
Возможно, это объясняется идейным влиянием ОС Unix. Набор операций ввода-вывода,
реализованных в этой ОС, стал общепризнанным стандартом де-факто и основой
для нескольких официальных стандартов. Например, набор операций ввода-вывода
в MS DOS является прямой копией Unix; кроме того, эти операции входят
в стандарт ANSI на системные библиотеки языка С и стандарт POSIX.
Современные системы семейства Unix разрешают программисту выбирать между
отложенной записью по принципу Fire And Forget (выстрелил и забыл) и полностью
синхронной, используя вызов fcntl с соответствующим
кодом операции.
Если все-таки нужен более детальный контроль над порядком обработки запросов,
разработчикам предлагается самостоятельно имитировать асинхронный обмен,
создавая для каждого асинхронно исполняемого запроса свою нить. Эта нить
тем или иным способом сообщает основной нити о завершении операции. Для
этого чаще всего используются штатные средства межпоточного взаимодействия
— семафоры и др. Грамотное использование нитей позволяет создавать интерактивные
приложения с очень высоким субъективным временем реакции, но за это приходится
платить усложнением логики программы. В Windows NT/2000/XP существует
средство оргащ, зации асинхронного ввода-вывода — так называемые
порты завершения (операции) (completion ports).
Однако это средство не поддерживается в Windows 95, поэтому большинство
разработчиков избегают использования портов завершения.
Синхронная модель ввода-вывода проста в реализации и использовании и,
как показал опыт систем семейства Unix и его идейных наследников, вполне
адекватна большинству приложений общего назначения. Однако, как уже было
показано, она не очень удобна (а иногда и просто непригодна) для задач
реального времени. Следует также иметь в виду, что имитация асинхронного
обмена при помощи нитей не всегда допустима: асинхронные запросы исполняются
в том порядке, в котором они устанавливались в очередь, а порядок получения
управления нитями в многозадачной среде не гарантирован. Поэтому, например,
стандарт POSIX.4 требует поддержки наравне с нитями и средств асинхронного
обмена с вызовом callback при завершении операции.
|
