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

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

#define N 5 /* число философов*/

void philosopher (int i) /* i – номер философа от 0 до 4*/

{

while (TRUE)

{

think(); /*философ думает*/

take_fork(i); /*берет левую вилку*/

take_fork((i+1)%N); /*берет правую вилку*/

eat(); /*ест*/

put_fork(i); /*кладет обратно левую вилку*/

put_fork((i+1)%N); /* кладет обратно правую вилку */

}

}

Функция take_fork(i) описывает поведение философа по захвату вилки: он ждет, пока указанная вилка не освободится, и забирает ее.

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

# define N 5 /* количество философов */

# define LEFT (i-1)%N /* номер легого соседа для i-ого философа */

# define RIGHT (i+1)%N /* номер правого соседа для i-ого философа*/

# define THINKING 0 /* философ думает */

# define HUNGRY 1 /* философ голоден */

# define EATING 2 /* философ ест */

typedef int semaphore; /* определяем семафор */

int state[N]; /* массив состояний каждого из философов */

semaphore mutex=1; /* семафор для критической секции */

semaphore s[N]; /* по одному семафору на философа */

void philosopher (int i) /* i : номер философа от 0 до N-1 */

{ while (TRUE) /* бесконечный цикл */

{ think(); /* философ думает */

take_forks(i); /*философ берет обе вилки или блокируется */

eat(); /* философ ест */

put_forks(i); /* философ кладет обе вилки на стол */

}

}

void take_forks(int i) /* i : номер философа от 0 до N-1 */

{ down(&mutex); /* вход в критическую секцию */

state[i] = HUNGRY; /*записываем, что i-ый философ голоден */

test(i); /* попытка взять обе вилки */

up(&mutex); /* выход из критической секции */

down(&s[i]); /* блокируемся, если вилок нет */

}

void put_forks(i) /* i : номер философа от 0 до N-1 */

{ down(&mutex); /* вход в критическую секцию */

state[i] = THINKING; /* философ закончил есть */

test(LEFT); /* проверить может ли левый сосед сейчас есть */

test(RIGHT); /* проверить может ли правый сосед сейчас есть*/

up(&mutex); /* выход из критической секции */

}

void test(i) /* i : номер философа от 0 до N-1 */

{ if (state[i] == HUNGRY && state[LEFT] != EATING && state[RIGHT] != EATING)

{

state[i] = EATING;

up (&s[i]);

}

}

Задача «читателей и писателей»

Другой классической задачей синхронизации доступа к ресурсам является проблема «читателей и писателей», иллюстрирующая широко распространенную модель совместного доступа к данным. Представьте себе ситуацию, например, в системе резервирования билетов, когда множество конкурирующих процессов хотят читать и обновлять одни и те же данные. Несколько процессов могут читать данные одновременно, но когда один процесс начинает записывать данные (обновлять базу данных проданных билетов), ни один другой процесс не должен иметь доступ к данным, даже для чтения. Вопрос, как спланировать работу такой системы? Одно из решений представлено ниже:

typedef int semaphore; /* некий семафор */

semaphore mutex = 1; /* контроль за доступом к «rc» (разделямый ресурс) */

semaphore db = 1; /* контроль за доступом к базе данных*/

int rc = 0; /* кол-во процессов читающих или пишущих */

void reader (void)

{

while (TRUE) /* бесконечный цикл */

{

down (&mutex); /* получить эксклюзивный доступ к «rc»*/

rc = rc+1; /* еще одним читателем больше */

if (rc==1) down (&db); /* если это первый читатель, нужно заблокировать эксклюзивный доступ к базе */

up(&mutex); /*освободить ресурс rc */

read_data_base(); /* доступ к данным */

down(&mutex); /*получить эксклюзивный доступ к «rc»*/

rc = rc-1: /* теперь одним читателем меньше */

if (rc==0) up(&db); /*если это был последний читатель, разблокировать эксклюзивный доступ

к базе данных */

up(&mutex); /*освободить разделяемый ресурс rc*/

use_data_read(); /* некритическая секция */

}

}

void writer (void)

{

while(TRUE) /* бесконечный цикл */

{

think_up_data(); /* некритическая секция */

down(&db); /* получить эксклюзивный доступ к данным*/

write_data_base(); /* записать данные */

up(&db); /* отдать эксклюзивный доступ */

}

}

В этом примере, первый процесс, обратившийся к базе данных по чтению, осуществляет операцию DOWN над семафором db, тем самым блокируя эксклюзивный доступ к базе, который нужен для записи. Число процессов, осуществляющих чтение в данный момент, определяется переменной rc (обратите внимание! Т.к. переменная rc является разделяемым ресурсом – ее изменяют все процессы, обращающиеся к базе данных по чтению – то доступ к ней охраняется семафором mutex). Когда читающий процесс заканчивает свою работу, он уменьшает rc на единицу. Если он является последним читателем, он также совершает операцию UP над семафором db, тем самым разрешая заблокированному писателю, если такой имелся, получить эксклюзивный доступ к базе для записи.

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

Задача о «спящем парикмахере»

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

Понадобится целых 3 семафора: customers – подсчитывает количество посетителей, ожидающих в очереди, barbers – обозначает количество свободных парикмахеров (в случае одного парикмахера его значения либо 0, либо 1) и mutex – используется для синхронизации доступа к разделяемой переменной waiting. Переменная waiting, как и семафор customers, содержит количество посетителей, ожидающих в очереди, она используется в программе для того, чтобы иметь возможность проверить, имеется ли свободное кресло для ожидания, и при этом не заблокировать процесс, если кресла не окажется. Заметим, что как и в предыдущем примере, эта переменная является разделяемым ресурсом, и доступ к ней охраняется семафором mutex.

#define CHAIRS 5

typedef int semaphore; /* тип данных «семафор» */

semaphore customers = 0; /* посетители, ожидающие в очереди */

semaphore barbers = 0; /* парикмахеры, ожидающие посетителей */

semaphore mutex = 1; /* контроль за доступом к переменной waiting */

int waiting = 0;

void barber()

{

while (true) {

down(customers); /* если customers == 0, т.е. посетителей нет, то заблокируемся до появления посетителя */

down(mutex); /* получаем доступ к waiting */

waiting = wating – 1; /* уменьшаем кол-во ожидающих клиентов */

up(barbers); /* парикмахер готов к работе */

up(mutex); /* освобождаем ресурс waiting */

cut_hair(); /* процесс стрижки */

}

void customer()

{

down(mutex); /* получаем доступ к waiting */

if (waiting < CHAIRS) /* есть место для ожидания */

{

waiting = waiting + 1; /* увеличиваем кол-во ожидающих клиентов */

up(customers); /* если парикмахер спит, это его разбудит */

up(mutex); /* освобождаем ресурс waiting */

down(barbers); /* если парикмахер занят, переходим в состояние ожидания, иначе – занимаем парикмахера*/

get_haircut(); /* процесс стрижки */

}

else

{

up(mutex); /* нет свободного кресла для ожидания – придется уйти */

}

}

Лекция 6 .Основы взаимодействия сети.

Время однопроцессорных компьютеров уходит. Даже те, которые мы называем однопроцессорными, по сути, многопроцессорные. Так, у них могут быть дополнительные функции обработки информации ( видео, взаимодействие с внешними устройствами…) Но, с другой стороны, приходит время , когда понимание процессора, как обработчика программы, тоже уходит => необходимость появления многопроцессорных архитектур. Причины:

• информационное общество (необходимость получения информации извне – Internet);

• появление спектра задач, для решения которых невозможно применять стандартные методы однопроцессорных систем, даже из-за объема этих задач

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

Многомашинные и многопроцессорные ассоциации.

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

Классификация архитектур Майкла Флина ( M. Flynn). Суть состоит в том, что рассматриваются 2 потока: поток инструкций (команд), и поток данных. Вот основные комбинации этих потоков:

• ОКОД (SISD – single instruction, single data stream) – традиционный, имеется 1 компьютер с единственным ЦП, на который подаются одиночные порции команд.

• ОКМД (SIMD - single instruction, multiple data stream) – матричная обработка данных. На 1 устройство управления поступают множественные потоки данных, т.е. для каждой инструкции можно выбрать порцию данных.

• МКОД (MISD - multiple instruction, single data stream) – в некотором смысле вырожденная каткгория, хотя к ней относятся, например, специальные параллельные графические системы.

• МКМД (MIMD - multiple instruction, multiple data stream) – множество процессоров одновременно выполняют различные последовательности команд над своими данными. Так или иначе 2 и более процессора со своими устройствами управления, каждое из кот. Может выполнять свою программу. Конвейерность становится свойством компа, а МКМД на сегодняшний день наиболее актуальны.

МКМД в свою очередь подразделяются на:

1) Системы с общей

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