logo

TechCodeview

Comunicació entre processos (IPC)

Un procés pot ser de dos tipus:

  • Procés independent.
  • Procés de cooperació.

Un procés independent no es veu afectat per l'execució d'altres processos, mentre que un procés de cooperació es pot veure afectat per altres processos d'execució. Tot i que es pot pensar que aquests processos, que s'executen de manera independent, s'executaran de manera molt eficient, en realitat, hi ha moltes situacions en què la naturalesa cooperativa es pot utilitzar per augmentar la velocitat computacional, la comoditat i la modularitat. La comunicació entre processos (IPC) és un mecanisme que permet als processos comunicar-se entre ells i sincronitzar les seves accions. La comunicació entre aquests processos es pot veure com un mètode de cooperació entre ells. Els processos es poden comunicar entre ells a través de tots dos:



  1. Memòria compartida
  2. Missatge passant

La figura 1 a continuació mostra una estructura bàsica de comunicació entre processos mitjançant el mètode de memòria compartida i mitjançant el mètode de pas de missatges.

Un sistema operatiu pot implementar ambdós mètodes de comunicació. Primer, parlarem dels mètodes de comunicació de memòria compartida i després de passar missatges. La comunicació entre processos que utilitzen memòria compartida requereix que els processos comparteixin alguna variable i depèn completament de com la implementi el programador. Una forma de comunicació utilitzant memòria compartida es pot imaginar així: suposem que el procés1 i el procés2 s'executen simultàniament i comparteixen alguns recursos o utilitzen informació d'un altre procés. Process1 genera informació sobre determinats càlculs o recursos que s'utilitzen i la conserva com a registre a la memòria compartida. Quan process2 necessiti utilitzar la informació compartida, comprovarà el registre emmagatzemat a la memòria compartida i prendrà nota de la informació generada per process1 i actuarà en conseqüència. Els processos poden utilitzar la memòria compartida per extreure informació com a registre d'un altre procés, així com per lliurar qualsevol informació específica a altres processos.
Parlem d'un exemple de comunicació entre processos mitjançant el mètode de memòria compartida.



i) Mètode de memòria compartida

Ex: Problema productor-consumidor
Hi ha dos processos: productor i consumidor. El productor produeix alguns articles i el consumidor consumeix aquest article. Els dos processos comparteixen un espai comú o una ubicació de memòria coneguda com a memòria intermèdia on s'emmagatzema l'article produït pel productor i des del qual el consumidor consumeix l'article si és necessari. Hi ha dues versions d'aquest problema: la primera es coneix com el problema de la memòria intermèdia il·limitada en la qual el productor pot continuar produint articles i no hi ha límit a la mida de la memòria intermèdia, la segona es coneix com a problema de la memòria intermèdia acotada a que el Productor pot produir fins a un nombre determinat d'articles abans de començar a esperar que el Consumidor el consumeixi. Parlarem del problema del buffer acotat. Primer, el productor i el consumidor compartiran una mica de memòria comú, després el productor començarà a produir articles. Si l'article total produït és igual a la mida del buffer, el productor esperarà que el consumeixi el consumidor. De la mateixa manera, el consumidor comprovarà primer la disponibilitat de l'article. Si no hi ha cap article disponible, el consumidor esperarà que el productor el produeixi. Si hi ha articles disponibles, el consumidor els consumirà. El pseudocodi per demostrar es proporciona a continuació:
Dades compartides entre els dos processos

C






#define buff_max 25> #define mod %> >struct> item{> >// different member of the produced data> >// or consumed data> >---------> >}> > >// An array is needed for holding the items.> >// This is the shared place which will be> >// access by both process> >// item shared_buff [ buff_max ];> > >// Two variables which will keep track of> >// the indexes of the items produced by producer> >// and consumer The free index points to> >// the next free index. The full index points to> >// the first full index.> >int> free_index = 0;> >int> full_index = 0;> > 

>

>

Codi de procés del productor

C




item nextProduced;> > >while>(1){> > >// check if there is no space> >// for production.> >// if so keep waiting.> >while>((free_index+1) mod buff_max == full_index);> > >shared_buff[free_index] = nextProduced;> >free_index = (free_index + 1) mod buff_max;> >}> 

>

>

Codi de processos de consum

C




item nextConsumed;> > >while>(1){> > >// check if there is an available> >// item for consumption.> >// if not keep on waiting for> >// get them produced.> >while>((free_index == full_index);> > >nextConsumed = shared_buff[full_index];> >full_index = (full_index + 1) mod buff_max;> >}> 

>

>

En el codi anterior, el Productor començarà a produir de nou quan el màxim buff mod (index_gratuït+1) estigui lliure perquè si no és gratuït, això implica que encara hi ha articles que poden ser consumits pel consumidor, de manera que no cal. per produir més. De la mateixa manera, si l'índex lliure i l'índex complet apunten al mateix índex, això implica que no hi ha articles per consumir.

Implementació general de C++:

C++




#include> #include> #include> #include> #define buff_max 25> #define mod %> struct> item {> >// different member of the produced data> >// or consumed data> >// ---------> };> // An array is needed for holding the items.> // This is the shared place which will be> // access by both process> // item shared_buff[buff_max];> // Two variables which will keep track of> // the indexes of the items produced by producer> // and consumer The free index points to> // the next free index. The full index points to> // the first full index.> std::atomic<>int>>índex_libre(0);> std::atomic<>int>>índex_complet(0);> std::mutex mtx;> void> producer() {> >item new_item;> >while> (>true>) {> >// Produce the item> >// ...> >std::this_thread::sleep_for(std::chrono::milliseconds(100));> >// Add the item to the buffer> >while> (((free_index + 1) mod buff_max) == full_index) {> >// Buffer is full, wait for consumer> >std::this_thread::sleep_for(std::chrono::milliseconds(100));> >}> >mtx.lock();> >// Add the item to the buffer> >// shared_buff[free_index] = new_item;> >free_index = (free_index + 1) mod buff_max;> >mtx.unlock();> >}> }> void> consumer() {> >item consumed_item;> >while> (>true>) {> >while> (free_index == full_index) {> >// Buffer is empty, wait for producer> >std::this_thread::sleep_for(std::chrono::milliseconds(100));> >}> >mtx.lock();> >// Consume the item from the buffer> >// consumed_item = shared_buff[full_index];> >full_index = (full_index + 1) mod buff_max;> >mtx.unlock();> >// Consume the item> >// ...> >std::this_thread::sleep_for(std::chrono::milliseconds(100));> >}> }> int> main() {> >// Create producer and consumer threads> >std::vectorthread>fils; threads.emplace_back(productor); threads.emplace_back(consumidor); // Espereu que els fils acabin per (auto& thread: threads) { thread.join(); } retorna 0; }>>> 

> 
    
  
  ii) Mètode de pas de missatgeria  
 
Ara, començarem la nostra discussió sobre la comunicació entre processos mitjançant el pas de missatges. En aquest mètode, els processos es comuniquen entre ells sense utilitzar cap tipus de memòria compartida. Si dos processos p1 i p2 volen comunicar-se entre ells, procedeixen de la següent manera: 
 
 
     
  • Establiu un enllaç de comunicació (si ja existeix un enllaç, no cal tornar-lo a establir).
    •  
  • Comenceu a intercanviar missatges utilitzant primitives bàsiques. 
    Necessitem almenys dos primitius: 
    – enviar (missatge, destinació) o enviar (missatge) 
    – rebre (missatge, amfitrió) o rebre (missatge)
    •  
 
 
 
La mida del missatge pot ser de mida fixa o variable. Si és de mida fixa, és fàcil per a un dissenyador de SO però complicat per a un programador i si és de mida variable, és fàcil per a un programador però complicat per al dissenyador de SO. Un missatge estàndard pot tenir dues parts: capçalera i cos.   
El part de capçalera s'utilitza per emmagatzemar el tipus de missatge, l'identificador de destinació, l'identificador de font, la longitud del missatge i la informació de control. La informació de control conté informació com què fer si es queda sense espai de memòria intermèdia, número de seqüència, prioritat. Generalment, el missatge s'envia amb l'estil FIFO. 
 
 
  Missatge passant per l'enllaç de comunicació.   
  Enllaç de comunicació directa i indirecta   
Ara, començarem la nostra discussió sobre els mètodes d'implementació d'enllaços de comunicació. Durant la implementació de l'enllaç, hi ha algunes preguntes que cal tenir en compte com: 
 
 
     
  1. Com s'estableixen els enllaços?
    2.  
  2. Es pot associar un enllaç a més de dos processos?
    3.  
  3. Quants enllaços hi pot haver entre cada parell de processos de comunicació?
    4.  
  4. Quina és la capacitat d'un enllaç? La mida d'un missatge que pot contenir l'enllaç és fixa o variable?
    5.  
  5. Un enllaç és unidireccional o bidireccional?
    6.  
 
Un enllaç té una capacitat que determina el nombre de missatges que hi poden residir temporalment per als quals cada enllaç té una cua associada que pot ser de capacitat zero, capacitat limitada o capacitat il·limitada. A capacitat zero, l'emissor espera fins que el receptor l'informa que ha rebut el missatge. En casos de capacitat diferent a zero, un procés no sap si s'ha rebut o no un missatge després de l'operació d'enviament. Per a això, l'emissor s'ha de comunicar explícitament amb el receptor. La implementació de l'enllaç depèn de la situació, pot ser un enllaç de comunicació directa o un enllaç de comunicació indirecta. 
  Enllaços de comunicació directa s'implementen quan els processos utilitzen un identificador de procés específic per a la comunicació, però és difícil identificar el remitent amb antelació. 
  Per exemple, el servidor d'impressió.   
  Comunicació indirecta es fa mitjançant una bústia compartida (port), que consta d'una cua de missatges. El remitent guarda el missatge a la bústia i el receptor el recull. 
 
 
  Missatge passant per l'intercanvi de missatges.  
 
  Transmissió de missatges síncrona i asíncrona:   
Un procés bloquejat és aquell que està esperant algun esdeveniment, com ara que un recurs estigui disponible o la finalització d'una operació d'E/S. L'IPC és possible entre els processos del mateix ordinador, així com en els processos que s'executen en un ordinador diferent, és a dir, en un sistema en xarxa/distribuït. En ambdós casos, el procés es pot bloquejar o no mentre s'envia un missatge o s'intenta rebre un missatge, de manera que el pas del missatge pot ser bloquejant o no. Es considera el bloqueig sincrònic i bloquejant l'enviament significa que el remitent estarà bloquejat fins que el receptor rebi el missatge. De la mateixa manera, bloqueig de rebre té el receptor bloquejat fins que hi hagi un missatge disponible. Es considera no bloqueig asíncron i Enviament sense bloqueig fa que el remitent enviï el missatge i continuï. De la mateixa manera, la recepció sense bloqueig fa que el receptor rebi un missatge vàlid o nul. Després d'una anàlisi acurada, podem arribar a la conclusió que per a un remitent és més natural no bloquejar després de passar el missatge ja que pot haver-hi la necessitat d'enviar el missatge a diferents processos. Tanmateix, l'emissor espera un reconeixement del receptor en cas que l'enviament falli. De la mateixa manera, és més natural que un receptor estigui bloquejant després d'emetre la recepció, ja que la informació del missatge rebut es pot utilitzar per a una execució posterior. Al mateix temps, si l'enviament del missatge continua fallant, el receptor haurà d'esperar indefinidament. Per això també considerem l'altra possibilitat de passar missatges. Bàsicament hi ha tres combinacions preferides: 
 
 
     
  • Bloqueig d'enviament i bloqueig de recepció
    •  
  • Enviament sense bloqueig i recepció sense bloqueig
    •  
  • Enviament sense bloqueig i recepció de bloqueig (s'utilitza principalment)
    •  
 
  En missatge directe , El procés que es vol comunicar ha d'anomenar explícitament el destinatari o remitent de la comunicació. 
per exemple. enviar(p1, missatge) significa enviar el missatge a p1. 
De la mateixa manera, rebre (p2, missatge) significa rebre el missatge de p2. 
En aquest mètode de comunicació, l'enllaç de comunicació s'estableix automàticament, que pot ser unidireccional o bidireccional, però es pot utilitzar un enllaç entre un parell d'emissor i receptor i un parell d'emissor i receptor no hauria de tenir més d'un parell de enllaços. La simetria i l'asimetria entre l'enviament i la recepció també es poden implementar, és a dir, o bé els dos processos s'anomenaran mútuament per enviar i rebre els missatges o només l'emissor anomenarà el receptor per enviar el missatge i no cal que el receptor anomena l'emissor. rebent el missatge. El problema d'aquest mètode de comunicació és que si el nom d'un procés canvia, aquest mètode no funcionarà. 
  En missatge indirecte de pas , els processos utilitzen bústies de correu (també anomenades ports) per enviar i rebre missatges. Cada bústia té un identificador únic i els processos només es poden comunicar si comparteixen una bústia. L'enllaç s'estableix només si els processos comparteixen una bústia de correu comuna i un únic enllaç es pot associar a molts processos. Cada parell de processos pot compartir diversos enllaços de comunicació i aquests enllaços poden ser unidireccionals o bidireccionals. Suposem que dos processos volen comunicar-se mitjançant la transmissió indirecta de missatges, les operacions necessàries són: crear una bústia de correu, utilitzar aquesta bústia per enviar i rebre missatges i després destruir la bústia. Les primitives estàndard utilitzades són: enviar un missatge) el que significa enviar el missatge a la bústia A. La primitiva per rebre el missatge també funciona de la mateixa manera, p. rebut (A, missatge) . Hi ha un problema amb la implementació d'aquesta bústia de correu. Suposem que hi ha més de dos processos que comparteixen la mateixa bústia i suposem que el procés p1 envia un missatge a la bústia, quin procés serà el receptor? Això es pot resoldre fent complir que només dos processos puguin compartir una única bústia o fer que només un procés pugui executar la recepció en un moment determinat o seleccionar qualsevol procés aleatòriament i notificar al remitent sobre el receptor. Una bústia de correu es pot fer privada per a un sol parell d'emissor/receptor i també es pot compartir entre diversos parells d'emissor/receptor. Port és una implementació d'aquesta bústia de correu que pot tenir diversos remitents i un sol receptor. S'utilitza en aplicacions client/servidor (en aquest cas el servidor és el receptor). El port és propietat del procés receptor i creat pel sistema operatiu a petició del procés receptor i es pot destruir a petició del mateix processador receptor quan el receptor s'acaba. Fer complir que només es permet un procés per executar la recepció es pot fer mitjançant el concepte d'exclusió mútua. Bústia Mutex es crea que és compartit per n procés. El remitent no bloqueja i envia el missatge. El primer procés que executa la recepció entrarà a la secció crítica i la resta de processos es bloquejaran i esperaran. 
Ara, analitzem el problema productor-consumidor utilitzant el concepte de transmissió de missatges. El productor col·loca articles (dins dels missatges) a la bústia de correu i el consumidor pot consumir un article quan hi ha almenys un missatge a la bústia. El codi es mostra a continuació: 
  Codi de productor   
 
 
C
    
 
     
  
 
    
 
     
     
    
 
 
  
  void> Producer(>void>){> > >int> item;> >Message m;> > >while>(1){> > >receive(Consumer, &m);> >item = produce();> >build_message(&m , item ) ;> >send(Consumer, &m);> >}> >}>  
  
 
    
 
>
 
    
 
>
 
 
  Codi de consum   
 
 
C
    
 
     
  
 
    
 
     
     
    
 
 
  
  void> Consumer(>void>){> > >int> item;> >Message m;> > >while>(1){> > >receive(Producer, &m);> >item = extracted_item();> >send(Producer, &m);> >consume_item(item);> >}> >}>  
  
 
    
 
>
 
    
 
>
 
 
  Exemples de sistemes IPC   
 
 
     
  1. Posix : utilitza el mètode de memòria compartida.
    2.  
  2. Mach : utilitza el pas de missatges
    3.  
  3. Windows XP: utilitza el pas de missatges mitjançant trucades de procediment local
    4.  
 
  Comunicació en Arquitectura client/servidor:   
Hi ha diversos mecanismes: 
 
 
     
  • Pipa
    •  
  • Endoll
    •  
  • Trucades de procediment remot (RPC)
    •  
 
Els tres mètodes anteriors es parlaran en articles posteriors, ja que tots són força conceptuals i mereixen els seus propis articles separats. 
  Referències:   
 
 
     
  1. Conceptes del sistema operatiu de Galvin et al.
    2.  
  2. Notes de la conferència/ppt d'Ariel J. Frank, Universitat Bar-Ilan
    3.  
 
La comunicació entre processos (IPC) és el mecanisme mitjançant el qual els processos o fils poden comunicar-se i intercanviar dades entre ells en un ordinador o a través d'una xarxa. L'IPC és un aspecte important dels sistemes operatius moderns, ja que permet que diferents processos treballin junts i comparteixin recursos, donant lloc a una major eficiència i flexibilitat.
 
Avantatges de l'IPC:
 
     
  1. Permet que els processos es comuniquin entre ells i comparteixin recursos, augmentant l'eficiència i la flexibilitat.
    2.  
  2. Facilita la coordinació entre diversos processos, donant lloc a un millor rendiment global del sistema.
    3.  
  3. Permet la creació de sistemes distribuïts que poden abastar diversos ordinadors o xarxes.
    4.  
  4. Es pot utilitzar per implementar diversos protocols de sincronització i comunicació, com ara semàfors, canonades i endolls.
    5.  
 
Desavantatges de l'IPC:
 
     
  1. Augmenta la complexitat del sistema, dificultant el disseny, la implementació i la depuració.
    2.  
  2. Pot introduir vulnerabilitats de seguretat, ja que els processos poden accedir o modificar dades pertanyents a altres processos.
    3.  
  3. Requereix una gestió acurada dels recursos del sistema, com ara la memòria i el temps de CPU, per garantir que les operacions IPC no degraden el rendiment global del sistema. 
    Pot provocar inconsistències de dades si diversos processos intenten accedir o modificar les mateixes dades al mateix temps.
    4.  
  4. En general, els avantatges de l'IPC superen els desavantatges, ja que és un mecanisme necessari per als sistemes operatius moderns i permet que els processos funcionin conjuntament i comparteixin recursos d'una manera flexible i eficient. Tanmateix, cal tenir cura de dissenyar i implementar sistemes IPC amb cura, per tal d'evitar possibles vulnerabilitats de seguretat i problemes de rendiment.
    5.  
 
Més referència: 
  http://nptel.ac.in/courses/106108101/pdf/Lecture_Notes/Mod%207_LN.pdf   
  https://www.youtube.com/watch?v=lcRqHwIn5Dk