Gestores de sincronización

(1)

Gestores de sincronizaci´ on

Lecturas:

Transparencias y apuntes de la asignatura

Manuel Carro

Universidad Polit´ecnica de Madrid

Este texto se distribuye bajo los t´erminos de la Creative Commons License

M. Carro (UPM) T´ecnicas O.P. 1 / 20

Gestores de sincronizaci´on

Un caso com´un:

I Exclusi´on mutua demasiado fuerte

I Necesitamos acceso de varios procesos

→ Separar datos fuera recurso

→ Usar recurso s´olo para sincronizar

Tipo Recurso = (Datos : . . . × Gestor : Tipo Gestor ) Usar Gestor s´olo para regular acceso

Gestores (Cont.)

Ejemplo de uso:

. . .

Gestor . I n i c i a r O p e r a c i o n X ; . . .

Gestor . T e r m i n a r O p e r a c i o n X ;

Iniciar Operacion Xpuede permitir el paso a varios procesos: uso de datos concurrente

Protocolo suele corresponder a una operaci´on de m´as alto nivel Debe ser encapsulada como tal

Operaci´on protegida debe ser reentrante

(2)

Ejemplo: lectores / escritores

Procesos quieren leer y escribir datos Lectores acceden concurrentemente datos Escritores acceden en exclusi´on mutua:

OPERACIONES

ACCI ÓN Leer: TipoBaseDeDatos . . . ACCI ÓN Escribir: TipoBaseDeDatos . . . SEMÁNTICA

DOMINIO:

TIPO: TipoBaseDeDatos = datos: . . . PROTOCOLOS: Leer

Escribir CONCURRENCIA: Leer^∗ Concurrencia: A | A || B | A*

Ejemplo: lectores / escritores (Cont.)

Datos siendo le´ıdos/escritos no relevantes: s´olo importa gestor C-TADSOL / recurso no utilizable directamente

Desdoblar:

I Inicio / terminaci´on lectura

I Inicio / terminaci´on escritura Cada una de ellas at´omica

Lectores y escritores: seguridad

ACCI ´ON IniciarLectura: TipoGestor[es]

ACCI ´ON TerminarLectura: TipoGestor[es]

ACCI ´ON IniciarEscritura: TipoGestor[es]

ACCI ´ON TerminarEscritura: TipoGestor[es]

PROTOCOLOS: Leer: IniciarLectura ; TerminarLectura Escribir: IniciarEscritura ; TerminarEscritura CONCURRENCIA: Leer*

TIPO: TipoGestor = (nLect: N× nEscrit: N)

INVARIANTE: ∀ g ∈ TipoGestor^•g.nLect = 0 ∨ g.nEscrit = 0

Gestor . I n i c i a r L e c t u r a ;

<<L e e r>>

Gestor . T e r m i n a r L e c t u r a ;

Gestor . I n i c i a r E s c r i t u r a ;

<<E s c r i b i r>>

Gestor . T e r m i n a r E s c r i t u r a ;

(3)

Lectores y escritores: seguridad (Cont.)

CPRE: g.nEscrit = 0 IniciarLectura (g)

POST: g^sal= g^ent\ g^sal.nLect = g^ent.nLect + 1 CPRE: cierto

TerminarLectura (g)

POST: g^sal=g^ent\ g^sal.nLect = g^ent.nLect - 1 CPRE: g.nLect = 0 ∧ g.nEscrit = 0

IniciarEscritura (g)

POST: g^sal=g^ent\ g^sal.nEscrit = g^ent.nEscrit + 1 CPRE: cierto

TerminarEscritura (g)

POST: g^sal=g^ent\ g^sal.nEscrit = g^ent.nEscrit - 1

N´umero escritores s´olo 0 o 1 → podemos usar un booleano

Tablas CPRE/POST

⁺

Operaci´on CPRE POST⁺

IniciarLectura ¬Escrib ¬Escrib ∧ nLect^ent≥ 0

∧nLect^sal= nLect^ent+ 1 IniciarEscritura ¬Escrib ∧

nLect = 0

nLect = 0 ∧Escrib

TerminarLectura cierto nLect^sal = nLect^ent − 1 ∧

¬Escrib

TerminarEscritura cierto ¬Escrib∧ nLect = 0

Leyenda: de invariante , de CPRE , de modo de uso

Lectores / escritores: grafo y vivacidad

(0, F) (1, F) . . . (P, F)

Ini.Lec.

Fin.Lec. Fin.Lec. Fin.Lec.

Ini.Lec.

(0, V)

Fin.Esc. Ini.Esc.

N´umero estados infinito (nLect ∈ N)

Pero, en la realidad, nLect ≤ n´umero procesos (protocolo:

IniciarLectura ; TerminalLectura)

Ciclos IniciarLectura /TerminarLecturano pasan por nodos donde se puede iniciar escrituras

Situaci´on intr´ınseca al problema (verlectsesc.adb) TerminarLectura, en cierto sentido, favorece IniciarLectura

(4)

Turno en lectores y escritores

Doble bloqueo: causar´ıa detenci´on Puntos a tratar:

I Evitar llegada continua lectores

I Decidir si entra lector o escritor al acabar un escritor Idea: dejar a un cierto n´umero de lectores

Flexibilidad: no fijar este n´umero

Turno: resuelve empate si lectores y escritores intentan entrar Turno de lectores: da preferencia a lectores si hay competencia Turno de escritores: al rev´es

Cambio de turno:

I El primer lector que termina

I El (primer) escritor que termina

Funcionamiento

E: escritor Li: lectores

Esperando L2, L3 L3

E

Ejecutando L1E L2L2

turnoLectura¬turnoLectura¬turnoLectura¬turnoLecturaturnoLectura

1 L2 y L3 pueden entrar; E no

2 L2 entra

3 L1 termina, cambia el turno, L3 no puede entrar

4 Ahora s´olo puede entrar E

5 E entra

6 Al salir cambia el turno; L3 puede entrar

Lectores / escritores: vivacidad

¿Cu´ando intenta entrar un escritor / lector?

Lectores, escritores bloqueados: atributo Count IniciarLectura ’ Count, IniciarEscritura ’ Count

Otros m´etodos en otros lenguajes / paradigmas de concurrencia (ej., monitores)

Supondemos nLectEsp, nEscEsp Puede simularse:

PROTOCOLOS: Leer: PermisoLect; IniciarLect; TerminarLect CONCURRENCIA: Leer*

Veremos c´omo quedan las precondiciones

nLectEsp y nEscEsp pueden implementarse de varios modos (dependiendo, p.ej., del lenguaje)

(5)

Lectores / escritores: tipo

Aumentamos tipo anterior

Nuevo: n´umero de procesos esperando, turno

TIPO: TipoGestor = (nLect : N × Escrib : B × turnoLect : B × nLectEsp : N × nEscEsp : N)

INVARIANTE: ∀g ∈ TipoGestor .(g .Escrib → g .nLect = 0)

Aumentamos tambi´en la sincronizaci´on Pero sin violar la seguridad:

CPREvivacidad → CPREseguridad

lectsesc.adbvs.lectsesc seg.adb

Lectores / escritores: vivacidad

CPRE: ¬g .nEscrib ∧ (turnoLect ∨ nEscEsp = 0) IniciarLectura (g)

POST: g^sal = g^ent\ g .nLect^sal= g .nLect^ent+ 1 CPRE: cierto

TerminarLectura (g)

POST: g^sal = g^ent\ g .nLect^sal= g .nLect^ent− 1 ∧ ¬turnoLect CPRE: ¬g .nEscrib ∧ nLect = 0 ∧ (¬turnoLect ∨ nLectEsp = 0)

IniciarEscritura (g) POST: g^sal = g^ent\ g .nEscrib CPRE: cierto

TerminarEscritura (g)

POST: g^sal = g^ent\ ¬g .nEscrib ∧ turnoLect

CPRE/POST

⁺

Operaci´on CPRE POST⁺

IniciarLectura ¬Escrib ∧ (turnoLect ∨ nEscEsp = 0)

nLect ≥ 0 ∧ ¬Escrib

∧nLect^sal = nLect^ent + 1∧

(turnoLect ∨ nEscEsp = 0) IniciarEscritura nLect = 0 ∧

¬Escrib ∧

(¬turnoLect ∨ nLectEsp = 0)

nLect = 0 ∧Escrib

TerminarLectura cierto ¬Escrib ∧¬turnoLect ∧ nLect^sal= nLect^ent− 1 TerminarEscritura cierto nLect = 0 ∧ ¬Escrib

∧turnoLect

(6)

Grafo con consideraciones de vivacidad

¿Asegura vivacidad la idea anterior?

Grafo: comprobaci´on no formal, pero ayuda a convencernos N´umero lectores, escritores expl´ıcito en estado

nLect, Escrib, TurnoL, nLectEsp, nEscEsp

daVinciV2.1

e(0,f,v,0,1)

e(0,v,v,0,0)

e(0,f,v,0,0)

Cero lectores, un escritor

daVinciV2.1

e(0,f,f,1,0) e(0,f,v,1,0)

e(1,f,f,0,0) e(1,f,v,0,0)

e(0,f,f,0,0) e(0,f,v,0,0)

Un lector, cero escritores

L´ımites de grafos de estados

daVinciV2.1

e(0,f,v,0,0) e(0,f,f,0,0)

e(0,v,v,0,0) e(0,v,f,0,0)

e(0,f,v,0,1) e(0,f,f,0,1)

e(1,f,v,0,0)

e(1,f,f,0,0) e(0,f,v,1,0)

e(0,f,f,1,0) e(1,f,v,0,1)

e(1,f,f,0,1)

e(0,v,v,1,0)

e(0,v,f,1,0)

e(0,f,v,1,1)

e(0,f,f,1,1)

Un lector, un escritor

Dif´ıcil percibir al aumentar n´umero procesos (ej., 5 lectores y 5 escritores: 312 estados) Complicado encontrar estructura

Mejor recurrir a:

I Representaciones alternativas grafos

I T´ecnicas con m´as base formal (tabla de desbloqueos)

Abstracci´on y determinismo en transiciones

No importa el n´umero concreto de procesos esperando

Ini.Lec.

Ter.Lec. Ter.Lec.

. . .

. . . Ini.Lec. Ini.Lec.

Ter.Lec. Ter.Lec.

Ter.Lec. Ter.Lec. Ter.Lec. Ter.Lec.

Ini.Esc.

Ter.Esc.

Ini.Lec. Ini.Lec. Ini.Lec. Ini.Lec.

[1] [1] [1] [1]

[2]

(0,f,f)

(0,v,f)

(0,f,v)

(0,v,v)

(1,f,v) (2,f,v) (k,f,v)

(k,f,f) (2,f,f)

(1,f,f)

[1] S´olo si no hay IniciarEscritura candidato [2] S´olo si no hay IniciarLectura candidato

(7)

Uso de turnos

Com´un: L/E s´olo un ejemplo

En esta caso s´olo dos tipos de procesos Puede haber varios:

I Diferenciados por la operaci´on llamada

I Diferenciados por los par´ametros

Ejemplo: puente estrecho

Coches intentan cruzar un puente

No hay espacio para ambas direcciones Similar a lectores/escritores

Modelizar y programar (con vivacidad) Dificultad adicional:

I Cada veh´ıculo un peso diferente

I Puente aguanta peso m´aximo (sumar el de los veh´ıculos)