Междупроцесни комуникации

Операционни системи, М. Филипова 1

Междупроцесни комуникации

гл. ас. Моника ФилиповаФМИ, Катедра Изчислителни системи


Аспекти при комуникация между процеси (Inter process communication или IPC)

Предаване на данни между процесите Гарантиране на коректно взаимодействие на процесите

Видове взаимодействия между процесиПроцеси, конкуриращи се за общ ресурсПример. Процеси P и Q, използващи обща променлива counter.Процес P Процес Q1.Чете counter в локална променлива pa.

2.Чете counter в локална променлива pb. 3. pb = pb + 2 4. Записва pb в counter.

5. pa = pa + 16. Записва pa в counter. Проблемът се нарича състезание (race condition), а

решението му - взаимно изключване (mutual exclusion).


Процеси, извършващи обща работа Производител-Потребител (Producer-Consumer) Читатели-Писатели (Readers and Writers) Задачата за обядващите философи (Dining Philosophers) За коректното взаимодействие на процесите е необходима

синхронизация (synchronization).

Механизми на ОС за решаване на IPC проблемите Обща памет (Shared memory) Семафори (Semaphores) Съобщения (Message passing)


Съдържание Взаимно изключване чрез обща памет

– Алгоритъм на Декер– Алгоритъм на Питерсон

Семафори– Взаимно изключване чрез семафори– Синхронизация чрез семафори

Съобщения– Адресиране на съобщенията– Буфериране на съобщенията


Взаимно изключванеMutual exclusion

Решение чрез обща памет


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

Процес е в критичния си участък, ако е започнал и не е завършил изпълнението му, независимо от състоянието си.

Условия за избягване на състезанието1. Във всеки момент най-много един процес може да се

намира в критичния си участък.2. Никой процес да не остава в критичния си участък

безкрайно дълго.3. Никой процес, намиращ се вън от критичния си участък, да

не пречи на друг процес да влезе в своя критичен участък.4. Решението не бива да се основава на предположения за

относителните скорости на процесите.

Критичен участък (critical section)


Алгоритъм с редуване на процесите

#define TRUE 1shared int turn=0;

P0(){ while (TRUE) { while (turn != 0); critical_section0(); turn = 1; noncritical_section0(); }}

P1(){ while (TRUE) { while (turn != 1); critical_section1(); turn = 0; noncritical_section1(); }}


Алгоритъм на Декерshared int wants0=FALSE, wants1=FALSE;shared int turn=0;

P0(){ while (TRUE) { wants0 = TRUE; while (wants1) if (turn == 1) { wants0 = FALSE;

while (turn == 1);wants0 = TRUE; }

critical_section0(); turn = 1; wants0 = FALSE; noncritical_section0(); }}

P1(){ while (TRUE) { wants1 = TRUE; while (wants0) if (turn == 0) { wants1 = FALSE;

while (turn == 0);wants1 = TRUE; }

critical_section1(); turn = 0; wants1 = FALSE; noncritical_section1(); }}


shared int turn=0;shared int interested[2] = {FALSE, FALSE};

enter_region(int process){int other; other = 1 - process; interested[process] = TRUE; turn = process; while (turn==process && interested[other]==TRUE);}

leave_region(int process){ interested[process] = FALSE;}

Алгоритъм на Питерсон


P0(){ while (TRUE) { enter_region(0); critical_section0(); leave_region(0); noncritical_section0(); }}

P1(){ while (TRUE) { enter_region(1); critical_section1(); leave_region(1); noncritical_section1(); }}

Недостатъци на алгоритмите за взаимно изключване взаимно изключване само на два процеса активно чакане (busy waiting)


Семафори

Взаимно изключване и синхронизация чрез семафори


Семафорът е обект, който има– брояч - цяло неотрицателно число– списък на процеси в състояние блокиран по семафора Операции над семафор Инициализацияsemaphore s = n;

Операция провери - P(s) или down(s)P(s){ if ( s > 0 ) s = s - 1; else блокира процеса, изпълняващ P по семафора s;}

Операция увеличи - V(s) или up(s)V(s){ if (има блокирани по семафора s процеси) събужда един процес; else s = s + 1;}


Взаимно изключване на n процеса#define TRUE 1semaphore mutex=1;

P0(){ while (TRUE) {

P(mutex) ; critical_section0(); V(mutex);

noncritical_section0(); }}

P1() ...{ while (TRUE) { P(mutex); critical_section1(); V(mutex); noncritical_section1(); }}


Синхронизация чрез семафори Операторите S1 в процеса P1 да се изпълнят преди S2 в P2semaphore s=0;

P1(){ ... S1; V(s); ...}

P2(){ ... P(s); S2; ...}


Производител - Потребителshared buffer buf; /* общ буфер с капацитет N елемента

*/semaphore mutex=1; /* за взаимно изключване */semaphore empty=N; /* брои свободните елементи в буфера

*/semaphore full=0; /* брои запълнените елементи в

буфера*/producer(){int item; while (TRUE) { produce_item(&item); P(empty); P(mutex); insert_item(item); V(mutex); V(full); }}

consumer(){int item; while (TRUE) { P(full); P(mutex); remove_item(&item); V(mutex); V(empty); consume_item(item); }}


Читатели - Писателиshared int rcount=0; /* брой процеси-читатели, които

четат */semaphore mutex=1; /* управлява достъпа до rcount */semaphore db=1; /* управлява достъпа до базата данни */reader(){ while(TRUE) { P(mutex); rcount = rcount + 1; if (rcount == 1) P(db); V(mutex); read_data_base(); P(mutex); rcount = rcount - 1; if (rcount == 0) V(db); V(mutex); }}

writer(){ while (TRUE) { collect_data(); P(db); write_data_base(); V(db); }}


Задача за обядващите философи

• Философът мисли или се храни• Нужни са му 2 вилици за да се

храни• Взима вилиците една по една • Как да се избегне дедлок

или "гладна смърт"?


Задача за обядващите философи (първи вариант)

#define N 5 /* броя на философите */

philosopher(int i) /* i е номер на философа */{ while(TRUE) { think(); take_fork(i); /* взима лявата вилица, като чака докато тя стане свободна */ take_fork((i+1)%N); /* взима дясната вилица, като също чака */ eat(); put_fork(i); /* връща лявата вилица */ put_fork((i+1)%N); /* връща дясната вилица */ }}


#define N 5#define LEFT (i-1)%N /* номер на левия съсед на i */#define RIGHT (i+1)%N /* номер на десния съсед на i */#define THINKING 0 /* философът мисли */#define HUNGRY 1 /* опитва се да вземе вилици */#define EATING 2 /* философът се храни */shared int state[N]={0,0,0,0,0}; /* състояния */semaphore mutex=1; /* взаимно изключване на state[N]*/semaphore s[N]={0,0,0,0,0}; /* по един на философ */

philosopher(int i){ while(TRUE) {

think();take_forks(i);eat();put_forks(i);

}}

Задача за обядващите философи (втори вариант)


take_forks(int i){ P(mutex); state[i] = HUNGRY; test(i); V(mutex); P(s[i]);}

put_forks(int i){ P(mutex); state[i] = THINKING; test(LEFT); test(RIGHT); V(mutex);}

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

state[i] = EATING;V(s[i]);

}}


Методи за междупроцесни комуникации

Чрез обща памет и семафори Двата аспекта на комуникацията - предаването на данните

и синхронизацията, се решават с различни механизми. Отговорността за комуникацията е на програмиста. Този метод не е безопасен. Чрез съобщения Двата аспекта на комуникацията се решават от механизма. Отговорността за комуникацията е на ОС. Този метод е по-безопасен.


Съобщения

Междупроцесни комуникации чрез съобщения


Между процесите се установява комуникационна връзка. Процесите обменят събщения чрез примитиви:

send(destination, message)receive(source, message)

1. Как се установява комуникационна връзка между процесите?

2. Може ли една комуникационна връзка да свързва повече от два процеса?

3. Колко комуникационни връзки може да има между два процеса?

4. Еднопосочна или двупосочна е комуникационната връзка?

5. Какво е капацитет на комуникационната връзка?6. Има ли някакви изисквания за размер и/или структура на

съобщенията предавани по определена комуникационна връзка?


Адресиране на съобщенията Директна комуникация

Всеки процес именува явно другия процес в примитива.Процес P Процес Qsend(Q, message); receive(P, message);1. Комуникационната връзка се установява автоматично

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

2. Комуникационната връзка свързва точно два процеса.3. Между всяка двойка процеси може да има само една

комуникационна връзка.4. Комуникационната връзка е двупосочна.

Асиметричен вариант на директна комуникацияreceive(ANY, message);


Косвена комуникацияСъобщения се изпращат в и получават от специален обект:– пощенска кутия (mailbox)– опашка на съобщенията (message queue)Процес P Процес Qsend(A, message); receive(A, message);1. Комуникационната връзка се установява между

процесите когато те използват обща пощенска кутия.2. Комуникационната връзка може да свързва и повече от

два процеса.3. Между два процеса може да съществува повече от една

комуникационна връзка.4. Комуникационната връзка може да е еднопосочна или

двупосочна.

Адресиране на съобщенията


Буфериране на съобщенията Съобщения без буфериране

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

Съобщения с автоматично буфериранеОпределен брой (обем) изпратени и още неполучени съобщения временно се съхраняват в комуникационната връзка.

След като изпълни send, изпращачът не може да знае дали съобщението му е получено.


Примери за реализации на съобщенияUNIX System V

Косвена комуникация - опашка на съобщенията Автоматично буфериране Структура на съобщение

struct msgbuf { long mtype; /* тип на съобщение*/ char mtext[N]; /* текст на съобщение */};

Опашка на съобщения се създава с примитив msgget. Процесът-собственик на опашката определя правата на

другите процеси. Опашка се унищожава явно с примитив msgctl. Съобщение се изпраща или получава с примитивите

msgsnd и msgrcv. Няколко потока за предаване на съобщения в рамките на

една опашка (двупосочна комуникационна връзка).


Примери за реализации на съобщения

MINIX Директна комуникация Без буфериране Събщения с фиксирана дължина

UNIX, MINIX, LINUX Програмен канал (pipe) – комуникация между "родствени"

процеси FIFO файл - комуникация между "независими" процеси Чрез програмен канал се предава неформатиран поток от

байтове, т.е. няма граници между "съобщенията".


Пример. Производител-Потребител чрез съобщения#include <sys/types.h>#include <sys/ipc.h>#include <sys/msg.h>#include <signal.h>

struct msgb{ long mtype; char mtext[256]; };

int mid;

void cleanup(){ if ( msgctl(mid, IPC_RMID, 0) == -1 ) {

perror( "Msgctl failed");exit(1); }

printf("MQ destroyed\n"); exit(0); }


main(void){struct msgb msg;int i, j, buf; if (( mid=msgget(24, IPC_CREAT|0666)) == -1 ) {

perror("Msgget failed"); exit(1); } signal(SIGINT, cleanup); if ( fork() ) { /* parent - consumer */

for ( i=0; ; i++ ) { msgrcv(mid, &msg, 256,1,0); buf = *((int*)msg.mtext); buf *= 2; printf("Consumer: %d\n", buf); }

} else { /* child - producer */signal(SIGINT, SIG_DFL);for (i=0; ; i++) { for ( j=0; j<100000; j++ ); msg.mtype = 1; *(int*)msg.mtext = i; msgsnd(mid, &msg,sizeof(int), 0);}

}}

Междупроцесни комуникации

Documents