Сетевые ОС

секция наиболее легко реализуется с использованием семафоров, мониторов и

аналогичных конструкций.

Нити могут быть реализованы как в пользовательском пространстве, так и в

пространстве ядра. В первом случае нити работают на базе прикладной

системы, управляющей всеми операциями с нитями. Первым преимуществом такого

способа является то, что можно реализовать нити в операционной системе,

которая их не поддерживает. ОС прикладная среда, управляющая нитями,

кажется одним процессом. Все вызовы (ПРИОСТАНОВИТЬ, ПРОВЕРИТЬ СЕМАФОР и т.

д.) обрабатываются как вызовы функций этой прикладной среды. Она сохраняет

регистры и переключает указатели счетчика команд и стека. В этом случае

переключение происходит быстрее, чем с помощью ядра. Такая реализация имеет

еще одно преимущество - для каждого процесса можно организовать свою схему

планирования. Однако этот подход связан с некоторыми проблемами, одна из

которых состоит в следующем. При выполнении блокирующих системных вызовов

приостанавливается весь набор нитей, принадлежащих этому процессу. Чтобы

избежать этого, можно сделать все системные вызовы неблокирующими, но это

требует изменений в ОС, что нежелательно, так как одной из целей реализации

нитей в пользовательском пространстве является их работа в существующих

операционных системах.

Такой проблемы не существует при реализации нитей в пространстве ядра.

Преимущество заключается также и в том, что ядро может при диспетчеризации

выбирать нить из другого процесса. Однако хотя механизм управления нитями

аналогичен первому случаю, временные затраты на переключение нитей выше,

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

4 Нити и RPC

Обычно в распределенных системах используются как RPC, так и нити. Так как

нити были введены как дешевая альтернатива стандартным процессам, то

естественно, что исследователи обратили особое внимание в этом контексте на

RPC: нельзя ли их также сделать облегченными. Было замечено, что в

распределенных системах значительное количество RPC обрабатывается на той

же машине, на которой они были вызваны (локально), например, вызовы к

менеджеру окон. Поэтому была предложена новая схема, которая делает

возможным для нити одного процесса вызвать нить другого процесса на этой же

машине более эффективно, чем обычным способом.

Идея заключается в следующем. Когда стартует серверная нить S, то она

экспортирует свой интерфейс, сообщая о нем ядру. Интерфейс определяет,

какие процедуры могут быть вызваны, каковы их параметры и т.п. Когда

стартует клиентская нить C, то она импортирует интерфейс из ядра в том

случае, если собирается вызвать S, и ей дается специальный идентификатор

для выполнения определенного вызова. Ядро теперь знает, что C собирается

позже вызвать S и создает специальные структуры данных для подготовки к

вызову.

Одна из этих структур данных является стеком аргументов, который

разделяется нитями C и S и отображается в оба адресных пространства для

чтения и записи. Для вызова сервера нить C помещает аргументы в разделяемый

стек, используя обычную процедуру передачи параметров, а затем прерывает

ядро, помещая данный ей идентификатор в регистр. По этому идентификатору

ядро видит, что вызов является локальным. (Если бы он был удаленным, то

ядро обработало бы его обычным способом для удаленных вызовов.) Затем ядро

выполняет переключение из адресного пространства клиента в адресное

пространство нити-сервера и запускает в рамках клиентской нити требуемую

процедуру сервера. При таком способе вызова аргументы уже загружены в

нужное место, так что копирование или перегруппировка аргументов не

требуется. Главный результат - локальный вызов RPC - будет выполнен этим

способом гораздо быстрее.

Другой прием широко используется для ускорения удаленных RPC. Идея основана

на следующем наблюдении: когда нить-сервер блокируется, ожидая нового

запроса, ее контекст почти всегда не содержит важной информации.

Следовательно, когда нить завершает обработку запроса, то ее просто

удаляют. При поступлении на сервер нового сообщения ядро создает новую нить

для обслуживания этого запроса. Кроме того ядро помещает сообщение в

адресное пространство сервера и устанавливает новый стек нити для доступа к

сообщению. Эту схему иногда называют неявным вызовом.

Этот метод имеет несколько преимуществ по сравнению с обычным RPC. Во-

первых, нити не должны блокироваться, ожидая новую работу, следовательно

контекст не нужно сохранять, во-вторых, создание новой нити проще, чем

активизация существующей приостановленной, так как не нужно восстанавливать

контекст.

Современные концепции и технологии проектирования операционных систем

1 Требования, предъявляемые к ОС 90-х годов

Операционная система является сердцевиной сетевого программного

обеспечения, она создает среду для выполнения приложений и во многом

определяет, какими полезными для пользователя свойствами эти приложения

будут обладать. В связи с этим рассмотрим требования, которым должна

удовлетворять современная ОС.

Очевидно, что главным требованием, предъявляемым к операционной системе,

является способность выполнения основных функций: эффективного управления

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

программ. Современная ОС, как правило, должна реализовывать

мультипрограммную обработку, виртуальную память, свопинг, поддерживать

многооконный интерфейс, а также выполнять многие другие, совершенно

необходимые функции. Кроме этих функциональных требований к операционным

системам предъявляются не менее важные рыночные требования. К этим

требованиям относятся:

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

легко внести дополнения и изменения, если это потребуется, и не нарушить

целостность системы.

Переносимость. Код должен легко переноситься с процессора одного типа на

процессор другого типа и с аппаратной платформы (которая включает наряду с

типом процессора и способ организации всей аппаратуры компьютера) одного

типа на аппаратную платформу другого типа.

Надежность и отказоустойчивость. Система должна быть защищена как от

внутренних, так и от внешних ошибок, сбоев и отказов. Ее действия должны

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

наносить вред ОС.

Совместимость. ОС должна иметь средства для выполнения прикладных программ,

написанных для других операционных систем. Кроме того, пользовательский

интерфейс должен быть совместим с существующими системами и стандартами.

Безопасность. ОС должна обладать средствами защиты ресурсов одних

пользователей от других.

Производительность. Система должна обладать настолько хорошим

быстродействием и временем реакции, насколько это позволяет аппаратная

платформа.

Рассмотрим более подробно некоторые из этих требований.

1 Расширяемость

В то время, как аппаратная часть компьютера устаревает за несколько лет,

полезная жизнь операционных систем может измеряться десятилетиями. Примером

может служить ОС UNIX. Поэтому операционные системы всегда эволюционно

изменяются со временем, и эти изменения более значимы, чем изменения

аппаратных средств. Изменения ОС обычно представляют собой приобретение ею

новых свойств. Например, поддержка новых устройств, таких как CD-ROM,

возможность связи с сетями нового типа, поддержка многообещающих

технологий, таких как графический интерфейс пользователя или объектно-

ориентированное программное окружение, использование более чем одного

процессора. Сохранение целостности кода, какие бы изменения не вносились в

операционную систему, является главной целью разработки.

Расширяемость может достигаться за счет модульной структуры ОС, при которой

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

через функциональный интерфейс. Новые компоненты могут быть добавлены в

операционную систему модульным путем, они выполняют свою работу, используя

интерфейсы, поддерживаемые существующими компонентами.

Использование объектов для представления системных ресурсов также улучшает

расширяемость системы. Объекты - это абстрактные типы данных, над которыми

можно производить только те действия, которые предусмотрены специальным

набором объектных функций. Объекты позволяют единообразно управлять

системными ресурсами. Добавление новых объектов не разрушает существующие

объекты и не требует изменений существующего кода.

Прекрасные возможности для расширения предоставляет подход к

структурированию ОС по типу клиент-сервер с использованием микроядерной

технологии. В соответствии с этим подходом ОС строится как совокупность

привилегированной управляющей программы и набора непривилегированных услуг-

серверов. Основная часть ОС может оставаться неизменной в то время, как

могут быть добавлены новые серверы или улучшены старые.

Средства вызова удаленных процедур (RPC) также дают возможность расширить

функциональные возможности ОС. Новые программные процедуры могут быть

добавлены в любую машину сети и немедленно поступить в распоряжение

прикладных программ на других машинах сети.

Некоторые ОС для улучшения расширяемости поддерживают загружаемые драйверы,

которые могут быть добавлены в систему во время ее работы. Новые файловые

системы, устройства и сети могут поддерживаться путем написания драйвера

устройства, драйвера файловой системы или транспортного драйвера и загрузки

его в систему.

2 Переносимость

Требование переносимости кода тесно связано с расширяемостью. Расширяемость

позволяет улучшать операционную систему, в то время как переносимость дает

возможность перемещать всю систему на машину, базирующуюся на другом

процессоре или аппаратной платформе, делая при этом по возможности

небольшие изменения в коде. Хотя ОС часто описываются либо как переносимые,

либо как непереносимые, переносимость - это не бинарное состояние. Вопрос

не в том, может ли быть система перенесена, а в том, насколько легко можно

это сделать. Написание переносимой ОС аналогично написанию любого

переносимого кода - нужно следовать некоторым правилам.

Во-первых, большая часть кода должна быть написана на языке, который

имеется на всех машинах, куда вы хотите переносить систему. Обычно это

означает, что код должен быть написан на языке высокого уровня,

предпочтительно стандартизованном, например, на языке С. Программа,

написанная на ассемблере, не является переносимой, если только вы не

собираетесь переносить ее на машину, обладающую командной совместимостью с

вашей.

Во-вторых, следует учесть, в какое физическое окружение программа должна

быть перенесена. Различная аппаратура требует различных решений при

создании ОС. Например, ОС, построенная на 32-битовых адресах, не может быть

перенесена на машину с 16-битовыми адресами (разве что с огромными

трудностями).

В-третьих, важно минимизировать или, если возможно, исключить те части

кода, которые непосредственно взаимодействуют с аппаратными средствами.

Зависимость от аппаратуры может иметь много форм. Некоторые очевидные формы

зависимости включают прямое манипулирование регистрами и другими

аппаратными средствами.

В-четвертых, если аппаратно зависимый код не может быть полностью исключен,

то он должен быть изолирован в нескольких хорошо локализуемых модулях.

Аппаратно-зависимый код не должен быть распределен по всей системе.

Например, можно спрятать аппаратно-зависимую структуру в программно-

задаваемые данные абстрактного типа. Другие модули системы будут работать с

этими данными, а не с аппаратурой, используя набор некоторых функций. Когда

ОС переносится, то изменяются только эти данные и функции, которые ими

манипулируют.

Для легкого переноса ОС при ее разработке должны быть соблюдены следующие

требования:

Переносимый язык высокого уровня. Большинство переносимых ОС написано на

языке С (стандарт ANSI X3.159-1989). Разработчики выбирают С потому, что он

стандартизован, и потому, что С-компиляторы широко доступны. Ассемблер

используется только для тех частей системы, которые должны непосредственно

взаимодействовать с аппаратурой (например, обработчик прерываний) или для

частей, которые требуют максимальной скорости (например, целочисленная

арифметика повышенной точности). Однако непереносимый код должен быть

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

Изоляция процессора. Некоторые низкоуровневые части ОС должны иметь доступ

к процессорно-зависимым структурам данных и регистрам. Однако код, который

делает это, должен содержаться в небольших модулях, которые могут быть

заменены аналогичными модулями для других процессоров.

Изоляция платформы. Зависимость от платформы заключается в различиях между

рабочими станциями разных производителей, построенными на одном и том же

процессоре (например, MIPS R4000). Должен быть введен программный уровень,

абстрагирующий аппаратуру (кэши, контроллеры прерываний ввода-вывода и т.

п.) вместе со слоем низкоуровневых программ таким образом, чтобы

высокоуровневый код не нуждался в изменении при переносе с одной платформы

на другую.

3 Совместимость

Одним из аспектов совместимости является способность ОС выполнять

программы, написанные для других ОС или для более ранних версий данной

операционной системы, а также для другой аппаратной платформы.

Необходимо разделять вопросы двоичной совместимости и совместимости на

уровне исходных текстов приложений. Двоичная совместимость достигается в

том случае, когда можно взять исполняемую программу и запустить ее на

выполнение на другой ОС. Для этого необходимы: совместимость на уровне

команд процессора, совместимость на уровне системных вызовов и даже на

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

Совместимость на уровне исходных текстов требует наличия соответствующего

компилятора в составе программного обеспечения, а также совместимости на

уровне библиотек и системных вызовов. При этом необходима перекомпиляция

имеющихся исходных текстов в новый выполняемый модуль.

Совместимость на уровне исходных текстов важна в основном для разработчиков

приложений, в распоряжении которых эти исходные тексты всегда имеются. Но

для конечных пользователей практическое значение имеет только двоичная

совместимость, так как только в этом случае они могут использовать один и

тот же коммерческий продукт, поставляемый в виде двоичного исполняемого

кода, в различных операционных средах и на различных машинах.

Обладает ли новая ОС двоичной совместимостью или совместимостью исходных

текстов с существующими системами, зависит от многих факторов. Самый

главный из них - архитектура процессора, на котором работает новая ОС. Если

процессор, на который переносится ОС, использует тот же набор команд

(возможно с некоторыми добавлениями) и тот же диапазон адресов, тогда

двоичная совместимость может быть достигнута достаточно просто.

Гораздо сложнее достичь двоичной совместимости между процессорами,

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

программы другого (например, DOS-программу на Mac), этот компьютер должен

работать с машинными командами, которые ему изначально непонятны. Например,

процессор типа 680x0 на Mac должен исполнять двоичный код, предназначенный

для процессора 80x86 в PC. Процессор 80x86 имеет свои собственные

дешифратор команд, регистры и внутреннюю архитектуру. Процессор 680x0 не

понимает двоичный код 80x86, поэтому он должен выбрать каждую команду,

декодировать ее, чтобы определить, для чего она предназначена, а затем

выполнить эквивалентную подпрограмму, написанную для 680x0. Так как к тому

же у 680x0 нет в точности таких же регистров, флагов и внутреннего

арифметико-логического устройства, как в 80x86, он должен имитировать все

эти элементы с использованием своих регистров или памяти. И он должен

тщательно воспроизводить результаты каждой команды, что требует специально

написанных подпрограмм для 680x0, гарантирующих, что состояние эмулируемых

регистров и флагов после выполнения каждой команды будет в точности таким

же, как и на реальном 80x86.

Это простая, но очень медленная работа, так как микрокод внутри процессора

80x86 исполняется на значительно более быстродействующем уровне, чем

эмулирующие его внешние команды 680x0. За время выполнения одной команды

80x86 на 680x0, реальный 80x86 может выполнить десятки команд.

Следовательно, если процессор, производящий эмуляцию, не настолько быстр,

чтобы компенсировать все потери при эмуляции, то программы, исполняющиеся

под эмуляцией, будут очень медленными.

Выходом в таких случаях является использование так называемых прикладных

сред. Учитывая, что основную часть программы, как правило, составляют

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

функции целиком, используя заранее написанную библиотеку функций

аналогичного назначения, а остальные команды эмулирует каждую по

отдельности.

Соответствие стандартам POSIX также является средством обеспечения

совместимости программных и пользовательских интерфейсов. Во второй

половине 80-х правительственные агентства США начали разрабатывать POSIX

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

контрактов в компьютерной области. POSIX - это "интерфейс переносимой ОС,

базирующейся на UNIX". POSIX - собрание международных стандартов

интерфейсов ОС в стиле UNIX. Использование стандарта POSIX (IEEE стандарт

1003.1 - 1988) позволяет создавать программы стиле UNIX, которые могут

легко переноситься из одной системы в другую.

4 Безопасность

В дополнение к стандарту POSIX правительство США также определило

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

правительством. Многие из этих требований являются желаемыми свойствами для

любой многопользовательской системы. Правила безопасности определяют такие

свойства, как защита ресурсов одного пользователя от других и установление

квот по ресурсам для предотвращения захвата одним пользователем всех

системных ресурсов ( таких как память).

Обеспечение защиты информации от несанкционированного доступа является

обязательной функцией сетевых операционных систем. В большинстве популярных

Страницы: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10