Page 1

Sistemas Operativos  

M.Sc. Julián Esteban Gutiérrez Posada M.Sc. Luis Eduardo Sepúlveda Rodríguez


Recordemos:   ¡  Cuando   dos   o   más   procesos   cooperan   para   solucionar   un   problema,   ya   sea   en   un   sistema   con   uno   o   varios   procesadores,   se   dice   que   e s t o s   p r o c e s o s   t r a b a j a n   d e   f o r m a   concurrente.    


Recordemos:   ¡  Dos  procesos  son  concurrentes  si  el  inicio  de   uno   de   ellos   ocurre   antes   de   la   terminación   del  otro.   ¡ 

Dos procesos   son   concurrentes   si   la     ejecución   de   los   procesos   se   traslapa   en   el   tiempo.  


¡ 

Un proceso   puede   verse   afectado   por   otro   cuando  uno  o  más  de  los  recursos  de  software  o   de   hardware   que   necesita   para   operar   correctamente,   son   requeridos   o   compartidos   por  más  procesos.  

¡ 

Para que   existan   procesos   cooperativos   es   necesario   que   el   sistema   operativo   brinde   servicios   de   comunicación   y   sincronización,   es   decir,   que   los   procesos   puedan   “hablar”     para   compartir   información   y   controlar   el   acceso   concurrente.  


¡ 

Los mecanismos  de  sincronización  tienen  como   objetivo:   §  El  control  de  acceso  a  los  recursos  compartidos  de  

hardware o  software.  

§  La asignación  de  recursos.   §  El  controlar  el  flujo  de  ejecución  (el  proceso  P  sólo  

debe ejecutarse  cuando  se  ejecute  completamente  el   proceso  Q).  


Suponga que  se  tienen  dos  transacciones  (A  y   B),  las  cuales  se  ejecutan  en  forma  concurrente   y  comparten  variables.   … TransacciónA(); TransacciónB(); …


Detalle de  las  transacciones  A  y  B  según  el  tiempo  de  ejecución   Tiempo  

Transacción A  

1

SaldoX =  2000  

2

SaldoA =  SaldoX  

3 4   5  

Transacción B  

SaldoB =  Saldo  X   SaldoX  =  SaldoA  -­‐  1000   Saldo  X  =  Saldo  B  -­‐  1000  

El valor  final  de  SaldoX  es  1000,  pero  debería  ser  0.     Por   lo   anterior   nos   damos   cuenta   que   no   debe   permitirse   el   acceso   indiscriminado   de   procesos   concurrentes   a   variables   o   recursos   compartidos.  


¡ 

El problema   de   la   “Actualización   perdida”   se   da   por   la   no   atomicidad   de   las   instrucciones,   es   decir   que   las   instrucciones   pueden   ser   interrumpidas   en   medio   de   su   ejecución   (una   instrucción   de   alto   nivel,   puede   ser   equivalente   a   más   de   una   instrucción  en  lenguaje  de  máquina).  

¡ 

Solución… respetar  la  sección  crítica   §  Considere  n  procesos  concurrentes,  en  los  cuales,  cada  uno  tiene  una  

zona en   su   código   en   la   cual   hace   referencia   a   un   componente   compartido.   A   estas   zonas   de   código   se   les   conoce   como   secciones   críticas.  

§  Entonces si   deseamos   garantizar   que   cuando   un   proceso   está  

ejecutando su  sección  crítica,  ningún  otro  proceso  que  tenga  recursos   compartidos  con  él,  puede  estar  ejecutando  su  sección  crítica.  


Para poder  garantizar  una  sincronización   efectiva,  han  aparecido  varias  alternativas:     ¡  Espera  Activa   ¡  Espera  no  activa  


¡ 

Solución por  software    

¡ 

se basan  en  mantener  los  procesos  que  esperan   entrar   a   su   sección   crítica,   en   un   ciclo   cuya   condición   se   rompe   cuando   el   proceso   que   estaba   en   su   sección   critica   termina,   y   que   se   activa   cada   vez   que   un   proceso   obtiene   acceso   a   su  sección  crítica.    

¡ 

Los procesos   que   esperan,   siguen   gastando   tiempo   de   procesamiento   en   verificar   dicha   condición  para  saber  si  quedan  o  no  en  el  ciclo.  


… EntrarEnSeccionCritica() { while( Condicion ); Condicion = TRUE; //SECCION CRITICA Condicion = FALSE; } …


¡ 

¡ 

Para evitar   que   un   proceso   gaste   tiempo   de   procesador   verificando   una   condición,   mientras   otro   sale   de   la   sección   crítica,   es   necesario   “dormirlo”  (Sleep).   Para   dormir   un   proceso,   basta   con   mover   su   PID   a  la  lista  de  procesos  en  espera.  Posteriormente   cuando  el  otro  proceso  termine  su  sección  crítica   es   necesario   “despertarlo”   (Wakeup)   o   mejor   dicho,   mover   su   PID   nuevamente   a   la   lista   de   procesos  listos.  


¡ 

Solución por  software    

¡ 

Una solución   que   utiliza   espera   no   activa   es   realizada   con   semáforos   (creados   por   E.W.  Dijkstra  en  1965).  

¡ 

Imagine que  existe  un  tipo  de   datos  llamado  S_Semaforo,   el  cual  es  una  estructura  de   datos  que  tiene  asociada  una   variable  entera  positiva  y  una   cola  (FIFO  –  First  In,  First  Out)   de  ID  de  procesos.  

… Struct S_Semaforo() { unsigned int Valor; T_Cola ColaPID; } …


¡ 

El sistema  operativo,  debe  brindar  dos  funciones   atómicas   que   manipulen   los   datos   asociados   a   un  semáforo,  Wait  y  Signal.    

¡ 

Los procesos  no  pueden  modificar  directamente   los   campos   asociados   a   un   semáforo,   es   decir,   deben   usar   las   funciones   que   brinda   el   sistema   operativo.  

¡ 

Solamente al  momento  de  creación  de  un   semáforo,  es  posible  la  asignación  asignar  un   valor  inicial  a  un  semáforo.  


Las funciones   Wait   y   Signal   se   implementan   en   la   forma   en   que   se   muestra  a  continuación:     ¡  Al  ejecutar  Wait,  se  verifica  si  el  valor  del  semáforo  es  igual  a  cero   (0).     ¡ 

Se obtiene  el  PID  del  proceso  actual.  

¡ 

Se coloca  su  PID  en  la  cola  del  semáforo    

¡ 

A través   de   una   solicitud   al   sistema   operativo,   este   proceso   se   duerme  (estado  de  espera)  

¡ 

Si por  el  contrario  su  valor  es  positivo,  simplemente  se  disminuye     en  uno  este  valor.  


Wait ( S_Semaforo ID_Sem ) { if ( ID_Sem.Valor == 0 ) { PID_Proceso = Obtener_PID_Proceso_Actual(); ID_Sem.Cola_ID.Ingrese (PID_Proceso); Sleep (PID_Proceso); } else ID_Sem.Valor = ID_Sem.Valor -1; }


¡ 

Si se   ejecuta   la   función   Signal,   se   retira   el   proceso   de   la   cola   del   semáforo,   se   le   pide   al   sistema   operativo   que   lo   despierte   (lo   pase   de   la   lista  de  procesos  listos).  Así  éste  podrá  pasar  sin   ningún  problema  a  ejecutar  su  sección  crítica.  

¡ 

Por supuesto,   todo   esto   es   transparente   para   los   procesos,   debido   a   que   sólo   invocan   las   funciones   Wait   y   Signal,   no   se   preocupan   de   cómo  están  construidas.  


Signal ( S_Semaforo ID_Sem ) { PID_Proceso = ID_Sem.Cola_ID.Retire(); if ( PID_Proceso =! NULL ) wakeup (PID_Proceso ); else ID_Sem.Valor = ID_Sem.Valor +1; }


S_Semaforo S S.Valor = 1

Hilo 1  

Wait (  S  )   //  Acceso   Signal(  S  )  

Hilo 2  

Wait (  S  )   //  Acceso   Signal(  S  )  


S_Semaforo E   E.Valor  =  1   Int  Num_Lectores  =  0   S_Semaforo    L   L.Valor  =  1    

Escritor(es)

Lector(es) Wait  (  L  )   Num_Lectores  ++   If  (  Num_Lectores  ==  1  )   Wait  (  E  )   Signal(  L  )     //  Acceso  a  leer     Wait  (  L  )   Num_Lectores  -­‐-­‐   If  (  Num_Lectores  ==  0  )   Signal  (  E  )   Signal(  L  )  

Wait (  E  )   //  Acceso  a  escribir   Signal(  E  )  


S_Semaforo E   E.Valor  =  1   Int  Num_Lectores  =  0   S_Semaforo    L,        A   L.Valor  =  1              A.Valor  =  5  

Escritor(es)

Lector(es) Wait  (  L  )   Num_Lectores  ++   If  (  Num_Lectores  ==  1  )   Wait  (  E  )   Signal(  L  )     Wait  (  A  )   //  Acceso  a  leer   Signal  (  A)       Wait  (  L  )   Num_Lectores  -­‐-­‐   If  (  Num_Lectores  ==  0  )   Signal  (  E  )   Signal(  L  )  

Wait (  E  )   //  Acceso  a  escribir   Signal(  E  )  


S_Semaforo S1,  S2   S1.Valor  =  0,  S2.Valor  =  0   P1  

P2

P3

// Ejecución  de  P1     Signal(  S1  )  

      Wait  (  S1  )   Wait  (  S2)     //  Ejecución  de  P2    

// Ejecución  de  P3     Signal(  S2  )    


S_Semaforo S1,  S2   S1.Valor  =  0,  S2.Valor  =  0   P1  

P2

              Wait  (  S2  )     //  Ejecución  de  P1    

// Ejecución  de  P2     Signal(  S1  )      

P3

Wait (  S1)     //  Ejecución  de  P3     Signal(  S2  )    

Sincronización de procesos  

sincronización de procesos por software

Read more
Read more
Similar to
Popular now
Just for you