Программные алгоритмы

Размещено на http://www.allbest.ru/

Размещено на http://www.allbest.ru/

1. Алгоритм Деккера и Петерсона

Взаимоисключение - возможность одному процессу приостановить остальные.

Критическая секция - участок кода, в котором должен находиться только один процесс.

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

2. если некоторый процесс находится в своем критическом участке и некоторый другой процесс захочет войти в свой критический участок, то это должно быть запрещено, то есть процесс должен быть заблокирован (переведен в ожидание)

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

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

5. процессы вне своих критических участков не должны мешать другим процессам входу в свои критические участки

Собственно алгоритм:

shared int ready[2] = {0,0}; // готовность ко входу

shared int turn; // чья очередь

while (условие) {

 // пролог

ready[i] = 1; // сообщаем о желании войти в КС

turn = 1 - i; // даем возможность входа другому процессу

while (ready[i-1] && (turn == 1-i)); // если очередь оказалась не нашей, ждем пока он не выйдет из КС

 // критическая секция

…

 // эпилог

ready[i] = 0; // сообщаем о выходе из КС

}

Требования к программной реализации:

* Не используется аппаратная поддержка

* Нет предположений о скорости процессоров и их количестве

* В критической секции только один процесс

* Условие ограниченного ожидания - если один процесс решил войти в свою критическую секцию, это не должно продолжаться неограниченно долго.

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

2. Механизм синхронизации. Семафоры

В 1965 разработан Дейкстрой (Dijkstra). Семафор - представляет из себяя целочисленную переменную, принимающую неотрицательные значения, доступ любого процесса к которой, за исключением момента её инициализации осуществляется только через две атомарные операции:

* P(S) - операция пролога критической секции

- Пока S=0 процесс блокируется

- Когда S>0, S=S-1

* V(S) - операция эпилога критической секции

- S = S +1

Операция V атомарна автоматически, атомарность P надо обеспечивать - программистом, аппаратным обеспечением или ОС.

Для задачи «потребитель-производитель» критической операцией будет любая работа с буфером.

semaphore mutex = 1; // бтв, я нихуц не понял почему переменные названы

semaphore empty = N; // именно так, ибо смысл у них обратный их

semaphore full = 0; // названиям. Так что я бы fullempty.

void Prod() { // производитель

while (1) {

Произвести(); // производим нечто

P(empty); // проверяем наличие места в буфере. Если полон (empty==0), залипаем, иначе уменьшаем количество места в нем на единицу

P(mutex); // залипаем если сейчас между P(mutex) и V(mutex) находится другой процесс

ПоложитьВБуфер();

V(mutex); // освобождаем mutex. Остальные процессы могут ходить сюда отныне

V(full); // увеличиваем количество элементов в буфере. Это разлепляет ожидающих потребителей

}

}

void Cons() { // потребитель

while (1) {

P(full); // проверяем есть ли в буфере что-нибудь. Если пуст (full==0), залипаем, иначе уменьшаем количество элементов на единицу.

P(mutex); // залипаем если сейчас между P(mutex) и V(mutex) находится другой процесс

ИзвлечьИзБуфера();

V(mutex); // освобождаем mutex. Остальные процессы могут ходить сюда отныне

V(empty); // увеличиваем количество свободного места на единицу. Это разлепляет производителей

ИспользоватьПолученныеДанные(); // радостно съедаем полученую из буфера нямку

}

}

3. Механизм синхронизации. Мониторы

Появились в 1974. Хор.

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

Строятся на основе языков ООП.

Монитор - особый тип данных, класс, содержащий ряд данных, работа с которыми может осуществляться только функциями и методами самого монитора.

monitor {

описание данных

void m1 (…) {…}

…

void mN(…) {…}

{инициализация /* выполняется один раз при создании монитора */}

}

Только один процесс может в один момент времени работать с монитором (находиться в состоянии исполнения или готовности к исполнению).

Это реализуется компилятором, путем добавления пролога и эпилога для входа и выхода из монитора. Однако, этого недостаточно для задач синхронизации, поэтому в мониторе есть две дополнительных операции - signal и wait. Обе операции выполняются над условной переменной, которая описывается в мониторе.

Если процесс выполняет wait(), он блокируется и переходит в состояние ожидания.

Если процесс выполняет signal(), он разблокирует процесс, который был ранее заблокирован операцией wait(). Разблокируется только один процесс. Если процессов в ожидании не было, ничего не происходит и информация о возникновении сигнала теряется.

monitor {

condition full, empty;

int count;

void put() {

if (count==N) full.wait();

ПоложитьВБуфер(el);

count++;

if (count==1) empty.signal(); // если раньше очередь была пуста, сигналим

}

void get();

{

if (count==0) empty.wait();

ИзвлечьИзБуфера();

count -;

if (count==(N-1)) full.signal();

}

 // инициализация:

{count = 0;}

}

Prod() { // производитель

while (1) {

ПРОИЗВОДИТ!

m.put();

}

}

Cons() { // потреблятель

while (1) {

m.get();

ПОТРЕБЛЯТ!}}

4. Механизм синхронизации процессов. Сообщения, эквивалентность механизмов синхронизации

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

Критическая секция (КС) - часть кода программы, которая может привести к конфликтам.

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

Структура КС: пролог, КС, эпилог.

Требования к алгоритмам взаимоисключений:

1. Решение программным путем.

2. Отсутствие предположений о количестве процессоров и их быстродействии.

3. Условие взаимоисключения, т.е. в КС находится только один процесс.

4. Условие прогресса - если процесс находится вне КС, он не должен препятствовать другим процессам входить в свои КС.

5. Условие ограниченного ожидания - если процесс захотел войти в КС это не должно откладываться бесконечно долго.

Механизмы синхронизации - высокоуровневые варианты реализации синхронизации с использованием средств ОС. Достоинством является возможность учета времени ожидания входа в КС. Реализуются компиляторами программно или с использованием аппаратных средств (семафоры, мониторы, сообщения).

Сообщения.

Наиболее простой механизм синхронизации. Реализуется с использованием 2х примитивов:

send (Q, mess) - отправить сообщение mess, процессу / объекту Q.

receive (Q, mess) - получить сообщение mess, от процесса / объекта Q.

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

- : медленно.

+: возможно использование для общения удаленных процессов.

Эквивалентность механизмов синхронизации.

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

Реализация мониторов с помощью семафоров.

Для этого нам нужно реализовывать взаимоисключения при входе в монитор и условные переменные. Возьмем семафор mutex с начальным значением 1 для реализации взаимоисключения при входе в монитор и по одному семафору ci для каждой условной переменной. Кроме того, для каждой условной переменной заведем счетчик fi для индикации наличия ожидающих процессов. Когда процесс входит в монитор, компилятор будет генерировать вызов функции monitor_enter, которая выполняет операцию P над семафором mutex для данного монитора. При нормальном выходе из монитора (то есть при выходе без вызова операции signal для условной переменной) компилятор будет генерировать вызов функции monitor_exit, которая выполняет операцию V над этим семафором.

Для выполнения операции wait над условной переменной компилятор будет генерировать вызов функции wait, которая выполняет операцию V для семафора mutex, разрешая другим процессам входить в монитор, и выполняет операцию P над соответствующим семафором ci, блокируя вызвавший процесс. Для выполнения операции signal над условной переменной компилятор будет генерировать вызов функции signal_exit, которая выполняет операцию V над ассоциированным семафором ci (если есть процессы, ожидающие соответствующего события), и выход из монитора, минуя функцию monitor_exit.

Код:

01 Semaphore mutex = 1;

02 void monitor_enter()

03 {

04 P(mutex);

05}

06 void monitor_exit()

07 {

08 V(mutex);

09}

10 Semaphore ci = 0;

11 int fi = 0;

12 void wait(i)

13 {

14 fi=fi + 1;

15 V(mutex);

16 P(ci);

17 fi=fi - 1;

18}

19 void signal_exit(i)

20 {

21 if(fi)

22 V(ci);

23 else

24 V(mutex);

25}

Заметим, что при выполнении функции signal_exit, если кто-либо ожидал этого события, процесс покидает монитор без увеличения значения семафора mutex, не разрешая тем самым всем процессам, кроме разбуженного, войти в монитор. Это увеличение совершит разбуженный процесс, когда покинет монитор обычным способом или когда выполнит новую операцию wait над какой-либо условной переменной.

Реализация сообщений через семафоры.

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

Процесс, желающий получить сообщение.

Процесс-получатель с номером i прежде всего выполняет операцию P(mutex), получая в монопольное владение разделяемую память. После чего он проверяет, есть ли в буфере сообщения. Если нет, то он заносит себя в список процессов, ожидающих сообщения, выполняет V(mutex) и P(ci). Если сообщение в буфере есть, то он читает его, изменяет счетчики буфера и проверяет, есть ли процессы в списке процессов, ожидающих записи. Если таких процессов нет, то выполняется V(mutex), и процесс-получатель выходит из КС. Если такой процесс есть (с номером j), то он удаляется из этого списка, выполняется V для его семафора cj, и выходим из КС. Проснувшийся процесс начинает выполняться в КС, так как mutex имеет значение 0 и никто более не может попасть в КС. При выходе из КС разбуженный процесс производит вызов V(mutex).

Работа процесса-отправителя (номером i). Процесс, посылающий сообщение, ждет, пока не сможет иметь монополию на использование разделяемой памяти, выполнив операцию P(mutex). Далее он проверяет, есть ли место в буфере, и если да, то помещает туда сообщение, изменяет счетчики и смотрит, есть ли процессы, ожидающие сообщения. Если нет, выполняет V(mutex) и выходит из КС, если есть, то «будит» один из них (с номером j), вызывая V(cj), с одновременным удалением этого процесса из списка процессов, ожидающих сообщений, и выходит из КС без вызова V(mutex), предоставляя тем самым возможность разбуженному процессу прочитать сообщение. Если места в буфере нет, то процесс-отправитель заносит себя в очередь процессов, ожидающих возможности записи, и вызывает V(mutex) и P(ci).

Реализация семафоров с помощью мониторов

Самый простой способ такой реализации выглядит следующим образом. Заведем внутри монитора переменную-счетчик, связанный с эмулируемым семафором списком блокируемых процессов и по одной условной переменной на каждый процесс. При выполнении операции P над семафором вызывающий процесс проверяет значение счетчика. Если оно больше нуля, уменьшает его на 1 и выходит из монитора. Если оно равно 0, процесс добавляет себя в очередь процессов, ожидающих события, и выполняет операцию wait над своей условной переменной. При выполнении операции V над семафором процесс увеличивает значение счетчика, проверяет, есть ли процессы, ожидающие этого события, и если есть, удаляет один из них из списка и выполняет операцию signal для условной переменной, соответствующей процессу.

Реализация семафоров с помощью очередей сообщений.

Для этого введем новый синхронизирующий процесс (СП). Этот процесс имеет счетчик и очередь для процессов, ожидающих включения семафора. Для того чтобы выполнить операции P и V, процессы посылают СП сообщения, в которых указывают свои потребности, после чего ожидают подтверждения от него.

После получения сообщения СП проверяет значение счетчика, чтобы выяснить, можно ли совершить требуемую операцию. Операция V всегда может быть выполнена, в то время как операция P может потребовать блокирования процесса. Если операция может быть совершена, то она выполняется, и СП посылает подтверждающее сообщение. Если процесс должен быть блокирован, то его идентификатор заносится в очередь блокированных процессов, и подтверждение не посылается. Позднее, когда какой-либо из других процессов выполнит операцию V, один из блокированных процессов удаляется из очереди ожидания и получает соответствующее подтверждение.

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

5. Распределение памяти разделами, перемещаемыми разделами

синхронизация код программный алгоритм

Распределение памяти фиксированными разделами.

Наиболее простой способ управления оперативной памятью (ОП). При этом вся память разделяется на некоторое количество разделов фиксированной величины, рзделение осуществляется либо оператором, либо при старте системы (запуске ОС). Очередной запущенный процесс поступивший на выполнение, помещается в общую очередь, либо в очередь к некоторому разделу.

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

Варианты определения раздела для загрузки:

1. первый попавшийся.

2. Наиболее подходящий.

3. Наименее подходящий.

+: простота реализации, запуск нескольких процессов, отсутствует внешняя фрагментация (вся память распределена по разделам)

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

Распределение памяти разделами переменной длины.

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

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

Задачи управления памятью: ведение таблиц свободных и занятых областей с указанием начальных адресов и размеров; выбор свободных областей достаточных для загрузки программы; загрузка программы и настройка ее адресов; корректировка таблиц.

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

- : большая внешняя фрагментация.

Распределение памяти перемещаемыми разделами.

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

Сжатие может производиться при каждом завершении процесса, либо когда для вновь поступившей задачи нет раздела достаточного размера.

Так как в данном случае программы становятся перемещаемыми в ходе выполнения, то связывание логических и физических адресов должно быть динамическим (во время выполнения).

+: отсутствие внутренней фрагментации; малая внефняя фрагментация.

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

6. Страничное распределение памяти

Память разделяется на страницы фиксированного размера (кратные степени 2, для х86 - 4Кб).

Логическое адресное пространство состоит из логических страниц, а физическое из физических.

Адрес представляет собой пару (p, d), где p - номер логической страницы, а d - смещение в ней.

Схема преодразования логического адреса (ЛА) в физический (ФА):

синхронизация код программный алгоритм

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

Реализуется программно или аппаратно (процессор имеет регистр с адресом таблицы страниц текущего процесса)

+:размещение произвольного количества процессов; процессы в физической памяти расположены произвольно, но для программиста память линейна; отсутствует внешняя фрагментация; минимальная внутренняя фрагментация (только в последней странице программы); защита памяти.

- : большие накладные расходы без аппаратной поддержки.

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

7. Сегментное распределение памяти

При сегментной организации памяти, память разбивается на сегменты. Сегменты могут иметь переменный размер, могут задаваться программистом или по умолчанию компилятором. Адрес сегмента двухкомпонентный. Максимальный размер сегмента определяется разрядностью адресной шины (т.е. при 32-разрядной шине использовать можно сегмент размерностью 2³² бит).

Адресное пространство процесса представляет собой набор сегментов, располагающихся непрерывно в памяти.

Преобразование адресов производится следующим образом (не для DOS):

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

На данный момент аппаратная поддержка сегментов реализована только в Intel.

Достоинства сегментной организации памяти:

- Защита памяти (имеется атрибут сегмента в таблице);

Недостатки:

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

8. Сегментно-страничное распределение памяти

Заключается в том, что сегмент состоит из страниц (см. вопрос 6,7 СПО).

Адрес состоит из трех полей:



Достоинства:

- Возможно совместное использование памяти процессами;

- Гибкая настройка прав доступа, т.к. у каждой таблицы имеются атрибуты.

Недостатки:

- Для доступа к данным необходимо три обращения.

9. Виртуальная память на основе сегментно-страничного распределения памяти

Виртуальная память.

Виртуальная память используется в качестве расширения доступной памяти. Ее особенность состоит в том, что она использует несколько уровней памяти (например, винчестер и ОП).

Появилась в 1959 г.

Суть состоит в следующем. Активный процесс располагается в ОП. Сам процесс разбивается на несколько частей (страниц, сегментов и т.п.). Автоматически происходит преобразование логического адреса в физический. Если страница отсутствует в ОП, то она должна быть в нее загружена. Присутствие страницы в той или иной памяти определяется битом присутствия.

Можно выделить следующие достоинства виртуальной памяти:

1) Программа не ограничена объемом ОП.

2) Есть возможность частичного размещения программ, что позволяет увеличить количество выполняемых программ.

3) Объем ввода / вывода информации значительно меньше, чем в классическом swapping'е (суть swapping'а - страницы копируются на винчестер при отсутствии места в ОП).

4) Объем адресуемой памяти становится равным максимальному объему для данной разрядности (к примеру, 32 разряда = 4 Гб).

Виртуальная память может быть распределена как:

а) страничная;

б) сегментная;

в) странично-сегментная.

Технология виртуализации памяти может быть полностью реализована программно.

Виртуальная память на основе сегментно-страничного разделения.

Основана на таблице страниц, куда добавляются биты:

1) Бит модификации (была ли изменена страница).

2) Бит присутствия (где страница лежит - в ОП или на винчестере).

3) Бит обращения (происходило ли обращение к странице).

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

Программное обеспечение для управления памятью связано с реализацией следующих стратегий:

1) Стратегия выборки - в какой момент следует переписать страницу из вторичной памяти в первичную. Существует два основных варианта выборки - по запросу и с упреждением. Алгоритм выборки по запросу вступает в действие в тот момент, когда процесс обращается к отсутствующей странице, содержимое которой находится на диске. Его реализация заключается в загрузке страницы с диска в свободную физическую страницу и коррекции соответствующей записи таблицы страниц.

Алгоритм выборки с упреждением осуществляет опережающее чтение, то есть кроме страницы, вызвавшей исключительную ситуацию, в память также загружается несколько страниц, окружающих ее (обычно соседние страницы располагаются во внешней памяти последовательно и могут быть считаны за одно обращение к диску). Такой алгоритм призван уменьшить накладные расходы, связанные с большим количеством исключительных ситуаций, возникающих при работе со значительными объемами данных.

2) Стратегия размещения - в какой участок первичной памяти поместить поступающую страницу.

3) Стратегия замещения - какую страницу нужно вытолкнуть во внешнюю память, чтобы освободить место в оперативной памяти. Для данной стратегии используются алгоритмы FIFO и др.

Размещено на Allbest.ru