65
D E P A R TA M E N T D 'IN FO RM ÀTICA D E S IS T E M E S I C O M P U TA D O R S Memoria Compartida Memoria Compartida Distribuida Distribuida José A. Gil Salinas José A. Gil Salinas Universidad Politécnica de Universidad Politécnica de Valencia Valencia Departamento de Informática Departamento de Informática de Sistemas y Computadores de Sistemas y Computadores

Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

Embed Size (px)

Citation preview

Page 1: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

D EPA RTA M EN T D 'IN F O RM À TICAD E SISTEM ES I CO M P U TA D O RSD EPA RTA M EN T D 'IN F O RM À TICAD E SISTEM ES I CO M P U TA D O RS

Memoria Compartida DistribuidaMemoria Compartida Distribuida

José A. Gil SalinasJosé A. Gil Salinas

Universidad Politécnica de ValenciaUniversidad Politécnica de Valencia

Departamento de Informática de Departamento de Informática de Sistemas y ComputadoresSistemas y Computadores

Page 2: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 22

IntroducciónIntroducción

Memoria compartida distribuida:Memoria compartida distribuida: Esfuerzo para combinar las mejores características de dos Esfuerzo para combinar las mejores características de dos

aproximaciones diferentes aproximaciones diferentes SMP - shared memory multiprocessingSMP - shared memory multiprocessingDCS - distributed computing systemsDCS - distributed computing systems

SMPSMP Modelo de programación simple, basado en un espacio de Modelo de programación simple, basado en un espacio de

direcciones compartidodirecciones compartido

No es escalableNo es escalable

DCSDCS Es escalableEs escalable

Modelo de programación difícil de usar, basado en varios Modelo de programación difícil de usar, basado en varios espacios de dirección distintos, y paso de mensajesespacios de dirección distintos, y paso de mensajes

Page 3: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 33

Modelo de programación: Locks y BarrerasModelo de programación: Locks y Barreras

Lock (bloqueo): mecanismo de protección en el Lock (bloqueo): mecanismo de protección en el acceso a recursos (memoria) compartidos.acceso a recursos (memoria) compartidos. Operaciones: aquire y releaseOperaciones: aquire y release

Barrera: mecanismo de sincronización adicional a Barrera: mecanismo de sincronización adicional a los locks.los locks. Sean N procesos distribuidos cooperantes.Sean N procesos distribuidos cooperantes.

Cada vez que uno de ellos encuentra una barrera, se bloquea Cada vez que uno de ellos encuentra una barrera, se bloquea hasta que el resto (N-1) alcanza la misma barrera.hasta que el resto (N-1) alcanza la misma barrera.

Se utilizan para separar fases del cómputo.Se utilizan para separar fases del cómputo.Es un punto donde se alcanza total consistencia, incluyendo Es un punto donde se alcanza total consistencia, incluyendo

datos externos a secciones críticas.datos externos a secciones críticas.Se asemejan a un par release-acquire.Se asemejan a un par release-acquire.

Epoch: porción de código comprendido entre dos Epoch: porción de código comprendido entre dos barreras.barreras.

Page 4: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 44

BarrerasBarreras

P1 P2 P3BARRIER BARRIER BARRIERA := 1

t1 acquire S1 … … B := 2

t2 release S1t3 acquire S1 acquire S2

… b := B a := At4 release S1 release S2

C := 3 … …t5 BARRIER BARRIER BARRIER

Page 5: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 55

Estructura y organización de un sistema DSMEstructura y organización de un sistema DSM

Page 6: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 66

IntroducciónIntroducción

Características principales de DSMCaracterísticas principales de DSM Modelo de programación simple de usarModelo de programación simple de usar Y es escalableY es escalable

Modelo de programación simpleModelo de programación simple Es una consecuencia del hecho que DSM está basado en Es una consecuencia del hecho que DSM está basado en

un solo espacio de dirección lógico. un solo espacio de dirección lógico.

Escalabilidad Escalabilidad Es una consecuencia del hecho que porciones diferentes Es una consecuencia del hecho que porciones diferentes

del espacio de direcciones (qué es lógicamente único) del espacio de direcciones (qué es lógicamente único) están implementadas en nodos de proceso diferentes están implementadas en nodos de proceso diferentes (físicamente distintos). (físicamente distintos).

Page 7: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 77

DSM y disciplinas asociadasDSM y disciplinas asociadas

SYSTEMTOPOLOGIES

AND

INTERCONNECTIONS

SH

AR

ED

ME

MO

RY

MU

LTIP

RO

CE

SS

OR

S

VIRTUAL

MEMORY

MANAGEMENT

DISTRIBUTED

DATABASES

PA

RA

LLE

LP

RO

GR

AM

MIN

GL

AN

GU

AG

ES

D ISTRIBUTED

OPERATING

SYSTEMS

H

AR

DW

AR

ESO

FT

WA

R

E

DSM

Page 8: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 88

DSM y su implementaciónDSM y su implementación

SoftwareSoftware Primeras implementaciones (multicomputadores y clusters Primeras implementaciones (multicomputadores y clusters

con paso de mensajes)con paso de mensajes) Nivel:Nivel:

Biblioteca de rutinasBiblioteca de rutinasPrimitivas insertadas por el compilador Primitivas insertadas por el compilador Sistema operativoSistema operativo

En el núcleoEn el núcleo Fuera del núcleoFuera del núcleo

Fáciles de construir y baratas de implementarFáciles de construir y baratas de implementar Lentas e ineficientesLentas e ineficientes

Page 9: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 99

DSM y su implementaciónDSM y su implementación

HardwareHardware Rápidas y eficientesRápidas y eficientes Relativamente complejas y carasRelativamente complejas y caras

Mixta (híbrida)Mixta (híbrida) Cada mecanismo puede ser implementado en el nivel Cada mecanismo puede ser implementado en el nivel

adecuado (Hw o Sw)adecuado (Hw o Sw) La mejor aproximación coste/prestacionesLa mejor aproximación coste/prestaciones

Page 10: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 1010

Organización interna de los datos compartidosOrganización interna de los datos compartidos

Los datos compartidos pueden ser de cualquier Los datos compartidos pueden ser de cualquier tipotipo No estructuradosNo estructurados EstructuradosEstructurados

Tipos de datos tradicionalesTipos de datos tradicionalesObjetosObjetos

Los datos compartidos son accedidos por Los datos compartidos son accedidos por segmentos de programa denominados secciones segmentos de programa denominados secciones críticas (que deben estar protegidas)críticas (que deben estar protegidas)

Page 11: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 1111

Granularidad de la consistenciaGranularidad de la consistencia

Tamaño de grano (determinado por el diseñador)Tamaño de grano (determinado por el diseñador) palabrapalabra bloquebloque páginapágina

pequeñapequeñagrandegrande

objetoobjeto segmentosegmento

Implementaciones Hw ~ grano pequeñoImplementaciones Hw ~ grano pequeño palabra, bloque o página pequeñapalabra, bloque o página pequeña

Implementaciones Sw ~ grano grandeImplementaciones Sw ~ grano grande página grande, objeto o segmentopágina grande, objeto o segmento

Implementaciones híbridas ~ grano medianoImplementaciones híbridas ~ grano mediano página pequeña o grandepágina pequeña o grande

Page 12: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 1212

Algoritmos de accesoAlgoritmos de acceso

SRSW (single reader / single writer) SRSW (single reader / single writer) Un solo nodo tiene permiso de lectura en un periodo de Un solo nodo tiene permiso de lectura en un periodo de

tiempo y sólo un nodo tiene permiso de escritura en ese tiempo y sólo un nodo tiene permiso de escritura en ese mismo periodomismo periodoDos réplicasDos réplicasEn sistemas con dos nodos ~ productor consumidor.En sistemas con dos nodos ~ productor consumidor.En sistemas con más nodos el algoritmo de gestión debe En sistemas con más nodos el algoritmo de gestión debe

permitir la migración.permitir la migración.

MRSW (multiple reader / single writer)MRSW (multiple reader / single writer) Varios nodos tienen permiso de lectura en un periodo de Varios nodos tienen permiso de lectura en un periodo de

tiempo y sólo un nodo tiene permiso de escritura en un tiempo y sólo un nodo tiene permiso de escritura en un periodo de tiempo.periodo de tiempo.Múltiples réplicasMúltiples réplicasNo es necesaria la migración en lectura.No es necesaria la migración en lectura.Migración de escritura necesaria.Migración de escritura necesaria.

Page 13: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 1313

Algoritmos de accesoAlgoritmos de acceso

MRMW (multiple reader / multiple writer)MRMW (multiple reader / multiple writer) Varios nodos tienen permiso de lectura y escritura en un Varios nodos tienen permiso de lectura y escritura en un

periodo de tiempo.periodo de tiempo.Múltiples réplicasMúltiples réplicasEs necesario un mecanismo (protocolo) para mantener la Es necesario un mecanismo (protocolo) para mantener la

consistencia de los datosconsistencia de los datos

Page 14: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 1414

Gestión de la propiedadGestión de la propiedad

Cada unidad de consistencia (grano) debe tener un Cada unidad de consistencia (grano) debe tener un nodo "home" responsable de la gestión de nodo "home" responsable de la gestión de propiedad de esa unidad.propiedad de esa unidad.

Una unidad de consistencia puede ser poseída por Una unidad de consistencia puede ser poseída por varios nodos en distintos intervalos de tiempo.varios nodos en distintos intervalos de tiempo.

El mecanismo de gestión puede ser centralizado o El mecanismo de gestión puede ser centralizado o distribuido.distribuido.

Page 15: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 1515

Protocolos de consistenciaProtocolos de consistencia

Al haber varias réplicas es Al haber varias réplicas es necesario mantener la necesario mantener la consistencia.consistencia.

Los protocolos se basan en Los protocolos se basan en una de estas políticas:una de estas políticas: actualizaciónactualización invalidacióninvalidación

El modelo de consistencia El modelo de consistencia determina CUANDO se determina CUANDO se enteran los nodos de los enteran los nodos de los cambios de valor de las cambios de valor de las variables.variables.

Cuanto más relajado el Cuanto más relajado el modelo más difícil la modelo más difícil la programación, pero mejores programación, pero mejores prestaciones.prestaciones.

Modelos de consistenciaModelos de consistencia RestringidosRestringidos

EstrictaEstricta SecuencialSecuencial

RelajadosRelajados ProcesadorProcesador Débil (weak)Débil (weak) Liberación (release)Liberación (release) Perezoso (lazy)Perezoso (lazy) Liberación perezosa (lazy Liberación perezosa (lazy

release)release) Entrada (entry)Entrada (entry) AURCAURC Ámbito (scope)Ámbito (scope) Generalizada (generalized)Generalizada (generalized)

Necesitan

prim

itivas

Necesitan

prim

itivas

de s

incro

niza

ción

de s

incro

niza

ción

Necesitan

prim

itivas

Necesitan

prim

itivas

de s

incro

niza

ción

de s

incro

niza

ción

Page 16: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 1616

Clasificación de los sistemas DSMClasificación de los sistemas DSM

Criterio: nivel de Criterio: nivel de implementación DSMimplementación DSM1.1. Hardware Hardware

2.2. Software Software 2.1. El sistema operativo 2.1. El sistema operativo

2.1.1. Dentro del núcleo2.1.1. Dentro del núcleo

2.1.2. Fuera del núcleo2.1.2. Fuera del núcleo

2.2. Biblioteca de rutinas2.2. Biblioteca de rutinas

2.3. Primitivas insertadas por 2.3. Primitivas insertadas por el compilador el compilador

3. Combinación de 3. Combinación de hardware/software hardware/software

Parámetros: Parámetros: 1. Conf. Arquitectónica 1. Conf. Arquitectónica

1.1. Configuración del cluster 1.1. Configuración del cluster (num. Procesadores, (num. Procesadores, mem. Compartida, mem. mem. Compartida, mem. Cache, niveles de cache) Cache, niveles de cache)

1.2. Red de interconexión 1.2. Red de interconexión (jerarquías de bus, anillo, (jerarquías de bus, anillo, malla, hipercubo, LAN malla, hipercubo, LAN específica etc.) específica etc.)

2. Organización de los datos 2. Organización de los datos compartidos compartidos

2.1. Estructura de datos (no 2.1. Estructura de datos (no estructurados o estructurados o estructurados en objetos, estructurados en objetos, tipos, etc.) tipos, etc.)

2.2 Grano de coherencia 2.2 Grano de coherencia (palabra, bloque de cache, (palabra, bloque de cache, página, estructura de página, estructura de datos, etc.) datos, etc.)

Page 17: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 1717

Clasificación de los sistemas DSMClasificación de los sistemas DSM

Segundo criterio: algoritmo Segundo criterio: algoritmo de DSM de DSM 1. SRSW (single reader / 1. SRSW (single reader /

single writer) single writer) 1.1. Sin migración 1.1. Sin migración

1.2. Con migración 1.2. Con migración

2.2. MRSW (multiple reader / MRSW (multiple reader / single writer) single writer)

3. 3. MRMW (multiple reader / MRMW (multiple reader / multiple writer) multiple writer)

Replicación: pueden existir Replicación: pueden existir copias múltiples de los copias múltiples de los mismos datosmismos datos

Migración: una sola copia Migración: una sola copia de datos que migra cuando de datos que migra cuando se accede, si no es localse accede, si no es local

Parámetros: Parámetros: 1. Responsabilidad de 1. Responsabilidad de

gestión de DSM gestión de DSM (centralizada, (centralizada, distribuida/fija, distribuida/fija, distribuida/dinámica) distribuida/dinámica)

2. Modelo de consistencia 2. Modelo de consistencia (strict, sequential, (strict, sequential, processor, weak, release, processor, weak, release, lazy release, entry, etc.) lazy release, entry, etc.)

3. Política de coherencia 3. Política de coherencia (write-invalidate, write-(write-invalidate, write-update, type-specific, etc.) update, type-specific, etc.)

Page 18: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 1818

Protocolos de consistenciaProtocolos de consistencia

Cronológicamente, las implementaciones relajadas Cronológicamente, las implementaciones relajadas software son anteriores. software son anteriores. La idea básica detrás de DSM software, a menudo llamado La idea básica detrás de DSM software, a menudo llamado

SVM (Memoria Virtual Compartida), es emular un protocolo SVM (Memoria Virtual Compartida), es emular un protocolo de coherencia de cache de granularidad de página en de coherencia de cache de granularidad de página en lugar de los bloques de cache.lugar de los bloques de cache.

En esas condiciones (granularidad más basta), el mayor En esas condiciones (granularidad más basta), el mayor problemas es la falsa compartición. problemas es la falsa compartición. la falsa compartición aparece cuando dos procesadores la falsa compartición aparece cuando dos procesadores

semánticamente no relacionados comparten la misma página semánticamente no relacionados comparten la misma página (accediendo datos no relacionado que están en la misma (accediendo datos no relacionado que están en la misma página), y uno de ellos escribe sus datos.página), y uno de ellos escribe sus datos.

el uso de consistencia relajada permite al sistema demorar la el uso de consistencia relajada permite al sistema demorar la actividad de coherencia desde el instante de modificación al actividad de coherencia desde el instante de modificación al instante del próximo punto de sincronización (liberación, instante del próximo punto de sincronización (liberación, adquisición o ambos). Posponer la actividad de coherencia adquisición o ambos). Posponer la actividad de coherencia significa que puede que la actualización/invalidación no significa que puede que la actualización/invalidación no ocurra.ocurra.

Page 19: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 1919

Protocolos de consistenciaProtocolos de consistencia

Consistencia estrictaConsistencia estricta TODOS los nodos se enteran INSTANTANEAMENTE de los TODOS los nodos se enteran INSTANTANEAMENTE de los

cambios (solo modelo teórico).cambios (solo modelo teórico).

Consistencia secuencialConsistencia secuencial El flujo particular de acceso y el flujo global de acceso que El flujo particular de acceso y el flujo global de acceso que

ve cada uno de los nodos son los mismos en todos los ve cada uno de los nodos son los mismos en todos los nodos.nodos.

Consistencia de procesadorConsistencia de procesador El flujo particular de acceso que ve cada uno de los nodos El flujo particular de acceso que ve cada uno de los nodos

es el mismo en todos los nodos. es el mismo en todos los nodos. El flujo global de acceso que ve cada uno de los nodos El flujo global de acceso que ve cada uno de los nodos

puede ser distinto.puede ser distinto.

Page 20: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 2020

Protocolos de consistenciaProtocolos de consistencia

Consistencia débil (weak)Consistencia débil (weak) Necesita puntos de sincronización (acquire - release) que Necesita puntos de sincronización (acquire - release) que

delimiten las secciones críticas.delimiten las secciones críticas. No se mantiene la consistencia fuera de las secciones No se mantiene la consistencia fuera de las secciones

críticas.críticas. La consistencia se mantiene en ambos puntos de La consistencia se mantiene en ambos puntos de

sincronización.sincronización. El código no puede continuar hasta que se establezca la El código no puede continuar hasta que se establezca la

consistencia en el punto de sincronización.consistencia en el punto de sincronización. Los puntos de sincronización siguen las reglas de la Los puntos de sincronización siguen las reglas de la

consistencia secuencial. (todos los nodos ven el mismo consistencia secuencial. (todos los nodos ven el mismo orden global de accesos).orden global de accesos).

Page 21: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 2121

Protocolos de consistenciaProtocolos de consistencia

Consistencia de liberación (release)Consistencia de liberación (release) La consistencia de memoria solamente se establece en los La consistencia de memoria solamente se establece en los

puntos de liberación.puntos de liberación. Los puntos de liberación siguen un modelo de Los puntos de liberación siguen un modelo de

consistencia de procesador.consistencia de procesador. En cada punto de liberación se actualizan el resto de los En cada punto de liberación se actualizan el resto de los

procesadores/procesos con los cambios de las variables.procesadores/procesos con los cambios de las variables.Esto genera tráfico potencialmente innecesario que puede Esto genera tráfico potencialmente innecesario que puede

tener un impacto negativo en la velocidad de ejecución de la tener un impacto negativo en la velocidad de ejecución de la aplicación.aplicación.

Page 22: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 2222

Protocolos de consistenciaProtocolos de consistencia

Release ConsistencyRelease Consistency Dash (hw)Dash (hw)

P1W(x) W(y) W(z) REL

t

t

x y z

P2

Munin (sw)Munin (sw)

P1W(x) W(y) W(z) REL

t

t

x,y,z

P2

P1W(x) REL

AC Q W(x) REL

AC Q W(x) REL

AC Q R(x) REL

t

t

t

t

P2

P3

P4

Page 23: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 2323

Protocolos de consistenciaProtocolos de consistencia

Liberación perezosa (lazy release)Liberación perezosa (lazy release) La consistencia de memoria sólo tiene que ser establecida La consistencia de memoria sólo tiene que ser establecida

en el punto de la siguiente adquisiciónen el punto de la siguiente adquisiciónEl tráfico incluirá sólo las variables actualizadas que podrían El tráfico incluirá sólo las variables actualizadas que podrían

usarse por la sección crítica de código que está a punto de usarse por la sección crítica de código que está a punto de empezar.empezar.

Se necesitará más espacio de "buffering" en cada Se necesitará más espacio de "buffering" en cada procesador, para guardar las variables actualizadas hasta procesador, para guardar las variables actualizadas hasta el comienzo de las siguientes secciones críticas.el comienzo de las siguientes secciones críticas.Notese que algunas de las variables actualizadas no se Notese que algunas de las variables actualizadas no se

usarán en la siguiente sección crítica. Sin embargo, esas usarán en la siguiente sección crítica. Sin embargo, esas variables contribuirán al tráfico (porque podrían ser usadas).variables contribuirán al tráfico (porque podrían ser usadas).

Page 24: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 2424

Protocolos de consistenciaProtocolos de consistencia

Lazy Release ConsistencyLazy Release Consistency TreadMarks (sw)TreadMarks (sw)

Protocolo de escritor múltiple que usa invalidación.Protocolo de escritor múltiple que usa invalidación. Cada escritor guarda todos los cambios (diff) que hace en todas Cada escritor guarda todos los cambios (diff) que hace en todas

las páginas compartidas, desde el último punto de acquire.las páginas compartidas, desde el último punto de acquire. En el siguiente punto de acquire, se envían write notices que En el siguiente punto de acquire, se envían write notices que

invalidan las páginas modificadas.invalidan las páginas modificadas. En el primer acceso a una página invalidada, se recogen los diffs En el primer acceso a una página invalidada, se recogen los diffs

y se aplican en el orden causal apropiado, para reconstruir la y se aplican en el orden causal apropiado, para reconstruir la página coherentemente.página coherentemente.

P1W(x) REL

ACQ W(x) REL

ACQ W(x) REL

ACQ R(x) REL

t

t

t

t

P2

P3

P4

x

x

x

fallo(x) diff

fallo(x) diff

fallo(x) diff

Page 25: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 2525

TreadMarks (estados y fallos)TreadMarks (estados y fallos)

Estados:Estados: UNMAPPEDUNMAPPED

Páginas compartidas que Páginas compartidas que no están en ese no están en ese procesadorprocesador

READ-ONLYREAD-ONLY Protegida para lecturaProtegida para lectura

READ-WRITEREAD-WRITE Protegida para escrituraProtegida para escritura

INVALIDINVALID Otro procesador ha escrito Otro procesador ha escrito

en ellaen ella

Tipos de Fallos de PáginaTipos de Fallos de Página cold_misscold_miss

la primera vez que un la primera vez que un procesador que no es el procesador que no es el manager accede a ellamanager accede a ella

coherence_misscoherence_miss acceso a una página acceso a una página

invalidadainvalidada

protection_faultprotection_fault acceso de ESCRITURA a acceso de ESCRITURA a

una página protegida para una página protegida para lecturalectura

Page 26: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 2626

TreadMarks (gestor de fallos)TreadMarks (gestor de fallos)

if ( p READ-ONLY ) thenif ( p READ-ONLY ) then

Allocate twinAllocate twin

Change protection to READ-WRITEChange protection to READ-WRITE

elseelse

if ( cold_miss) thenif ( cold_miss) then

get copy from managerget copy from manager

if ( write notices ) thenif ( write notices ) then

Retrieve diffsRetrieve diffs

if ( write miss ) thenif ( write miss ) then

Allocate twinAllocate twin

Change protection to READ-WRITEChange protection to READ-WRITE

elseelse

Change protection to READ-ONLYChange protection to READ-ONLY

Page 27: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 2727

TreadMarks (diagrama de estados)TreadMarks (diagrama de estados)

UNMAPPEDUNMAPPEDUNMAPPEDUNMAPPED

READ-READ-WRITEWRITEREAD-READ-WRITEWRITEREAD-ONLYREAD-ONLYREAD-ONLYREAD-ONLY

INVALIDINVALIDINVALIDINVALID

READREADFAULTFAULTREADREADFAULTFAULT

WRITEWRITEFAULTFAULTWRITEWRITEFAULTFAULT

READREADFAULTFAULTREADREADFAULTFAULT

WRITEWRITEFAULTFAULTWRITEWRITEFAULTFAULT

WRITEWRITENOTICENOTICEWRITEWRITE

NOTICENOTICE

WRITEWRITENOTICENOTICEWRITEWRITE

NOTICENOTICE

WRITEWRITEFAULTFAULTWRITEWRITEFAULTFAULT

DIFFDIFFCREATECREATE

DIFFDIFFCREATECREATE

Los WRITE FALUT generan TWINLos WRITE FALUT generan TWINLos DIFF CREATE eliminan los TWINLos DIFF CREATE eliminan los TWINLos WRITE FALUT generan TWINLos WRITE FALUT generan TWINLos DIFF CREATE eliminan los TWINLos DIFF CREATE eliminan los TWIN

Page 28: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 2828

TreadMarks (ejemplo de programa)TreadMarks (ejemplo de programa)

#include <stdio.h>#include <stdio.h>

#include "Tmk.h"#include "Tmk.h"

struct shared {struct shared {

int sum;int sum;

int turn;int turn;

int* array;int* array;

} *shared;} *shared;

main(int argc, char **argv)main(int argc, char **argv)

{{

int start, end, i, p;int start, end, i, p;

int arrayDim = 100;int arrayDim = 100;

/* Read array size from command line */ {/* Read array size from command line */ {

int c;int c;

extern char* optarg;extern char* optarg;

while ((c = getopt(argc, argv, "d:")) != -while ((c = getopt(argc, argv, "d:")) != -1)1)

switch (c) {switch (c) {

case 'd':case 'd':

arrayDim = atoi(optarg);arrayDim = atoi(optarg);

break;break;

}}

}}

Tmk_startup(argc, argv);Tmk_startup(argc, argv);

......

#include <stdio.h>#include <stdio.h>

#include "Tmk.h"#include "Tmk.h"

struct shared {struct shared {

int sum;int sum;

int turn;int turn;

int* array;int* array;

} *shared;} *shared;

main(int argc, char **argv)main(int argc, char **argv)

{{

int start, end, i, p;int start, end, i, p;

int arrayDim = 100;int arrayDim = 100;

/* Read array size from command line */ {/* Read array size from command line */ {

int c;int c;

extern char* optarg;extern char* optarg;

while ((c = getopt(argc, argv, "d:")) != -while ((c = getopt(argc, argv, "d:")) != -1)1)

switch (c) {switch (c) {

case 'd':case 'd':

arrayDim = atoi(optarg);arrayDim = atoi(optarg);

break;break;

}}

}}

Tmk_startup(argc, argv);Tmk_startup(argc, argv);

......

Page 29: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 2929

TreadMarks (ejemplo de programa)TreadMarks (ejemplo de programa)

......

Tmk_startup(argc, argv);Tmk_startup(argc, argv);

if (Tmk_proc_id == 0) {if (Tmk_proc_id == 0) {

shared = (struct shared *) Tmk_malloc(sizeof(shared));shared = (struct shared *) Tmk_malloc(sizeof(shared));

if (shared == NULL)if (shared == NULL)

Tmk_exit(-1);Tmk_exit(-1);

/* share common pointer with all procs *//* share common pointer with all procs */

Tmk_distribute(&shared, sizeof(shared));Tmk_distribute(&shared, sizeof(shared));

shared->array = (int *) Tmk_malloc(arrayDim * sizeof(int));shared->array = (int *) Tmk_malloc(arrayDim * sizeof(int));

if (shared->array == NULL)if (shared->array == NULL)

Tmk_exit(-1);Tmk_exit(-1);

shared->turn = 0;shared->turn = 0;

shared->sum = 0;shared->sum = 0;

}}

Tmk_barrier(0);Tmk_barrier(0);

......

......

Tmk_startup(argc, argv);Tmk_startup(argc, argv);

if (Tmk_proc_id == 0) {if (Tmk_proc_id == 0) {

shared = (struct shared *) Tmk_malloc(sizeof(shared));shared = (struct shared *) Tmk_malloc(sizeof(shared));

if (shared == NULL)if (shared == NULL)

Tmk_exit(-1);Tmk_exit(-1);

/* share common pointer with all procs *//* share common pointer with all procs */

Tmk_distribute(&shared, sizeof(shared));Tmk_distribute(&shared, sizeof(shared));

shared->array = (int *) Tmk_malloc(arrayDim * sizeof(int));shared->array = (int *) Tmk_malloc(arrayDim * sizeof(int));

if (shared->array == NULL)if (shared->array == NULL)

Tmk_exit(-1);Tmk_exit(-1);

shared->turn = 0;shared->turn = 0;

shared->sum = 0;shared->sum = 0;

}}

Tmk_barrier(0);Tmk_barrier(0);

......

Page 30: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 3030

TreadMarks (ejemplo de programa)TreadMarks (ejemplo de programa)

......

Tmk_barrier(0);Tmk_barrier(0);

/* Determine array range for each processor */ {/* Determine array range for each processor */ {

int id0 = Tmk_proc_id, id1 = Tmk_proc_id+1;int id0 = Tmk_proc_id, id1 = Tmk_proc_id+1;

int perProc = arrayDim / Tmk_nprocs;int perProc = arrayDim / Tmk_nprocs;

int leftOver = arrayDim % Tmk_nprocs;int leftOver = arrayDim % Tmk_nprocs;

start = id0 * perProc + id0 * leftOver / Tmk_nprocs;start = id0 * perProc + id0 * leftOver / Tmk_nprocs;

end = id1 * perProc + id1 * leftOver / Tmk_nprocs;end = id1 * perProc + id1 * leftOver / Tmk_nprocs;

}}

for (i = start; i < end; i++)for (i = start; i < end; i++)

shared->array[i] = i;shared->array[i] = i;

Tmk_barrier(0);Tmk_barrier(0);

......

......

Tmk_barrier(0);Tmk_barrier(0);

/* Determine array range for each processor */ {/* Determine array range for each processor */ {

int id0 = Tmk_proc_id, id1 = Tmk_proc_id+1;int id0 = Tmk_proc_id, id1 = Tmk_proc_id+1;

int perProc = arrayDim / Tmk_nprocs;int perProc = arrayDim / Tmk_nprocs;

int leftOver = arrayDim % Tmk_nprocs;int leftOver = arrayDim % Tmk_nprocs;

start = id0 * perProc + id0 * leftOver / Tmk_nprocs;start = id0 * perProc + id0 * leftOver / Tmk_nprocs;

end = id1 * perProc + id1 * leftOver / Tmk_nprocs;end = id1 * perProc + id1 * leftOver / Tmk_nprocs;

}}

for (i = start; i < end; i++)for (i = start; i < end; i++)

shared->array[i] = i;shared->array[i] = i;

Tmk_barrier(0);Tmk_barrier(0);

......

Page 31: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 3131

TreadMarks (ejemplo de programa)TreadMarks (ejemplo de programa)

......

Tmk_barrier(0);Tmk_barrier(0);

/* Print array elements, in the natural output order *//* Print array elements, in the natural output order */

for (p = 0; p < Tmk_nprocs; p++) {for (p = 0; p < Tmk_nprocs; p++) {

if (shared->turn == Tmk_proc_id) {if (shared->turn == Tmk_proc_id) {

for (i = start; i < end; i++)for (i = start; i < end; i++)

printf("%d: %d\n", i, shared->array[i]);printf("%d: %d\n", i, shared->array[i]);

shared->turn++;shared->turn++;

}}

Tmk_barrier(0);Tmk_barrier(0);

}}

......

......

Tmk_barrier(0);Tmk_barrier(0);

/* Print array elements, in the natural output order *//* Print array elements, in the natural output order */

for (p = 0; p < Tmk_nprocs; p++) {for (p = 0; p < Tmk_nprocs; p++) {

if (shared->turn == Tmk_proc_id) {if (shared->turn == Tmk_proc_id) {

for (i = start; i < end; i++)for (i = start; i < end; i++)

printf("%d: %d\n", i, shared->array[i]);printf("%d: %d\n", i, shared->array[i]);

shared->turn++;shared->turn++;

}}

Tmk_barrier(0);Tmk_barrier(0);

}}

......

Page 32: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 3232

TreadMarks (ejemplo de programa)TreadMarks (ejemplo de programa)

......

Tmk_barrier(0);Tmk_barrier(0);

}}

/* Compute local sum, then add to global sum */ {/* Compute local sum, then add to global sum */ {

int mySum = 0;int mySum = 0;

for (i = start; i < end; i++)for (i = start; i < end; i++)

mySum += shared->array[i];mySum += shared->array[i];

Tmk_lock_acquire(0);Tmk_lock_acquire(0);

shared->sum += mySum;shared->sum += mySum;

Tmk_lock_release(0);Tmk_lock_release(0);

}}

if (Tmk_proc_id == 0) {if (Tmk_proc_id == 0) {

Tmk_free(shared->array);Tmk_free(shared->array);

Tmk_free(shared);Tmk_free(shared);

printf("Sum is %d\n", shared->sum);printf("Sum is %d\n", shared->sum);

}}

Tmk_exit(0);Tmk_exit(0);

}}

......

Tmk_barrier(0);Tmk_barrier(0);

}}

/* Compute local sum, then add to global sum */ {/* Compute local sum, then add to global sum */ {

int mySum = 0;int mySum = 0;

for (i = start; i < end; i++)for (i = start; i < end; i++)

mySum += shared->array[i];mySum += shared->array[i];

Tmk_lock_acquire(0);Tmk_lock_acquire(0);

shared->sum += mySum;shared->sum += mySum;

Tmk_lock_release(0);Tmk_lock_release(0);

}}

if (Tmk_proc_id == 0) {if (Tmk_proc_id == 0) {

Tmk_free(shared->array);Tmk_free(shared->array);

Tmk_free(shared);Tmk_free(shared);

printf("Sum is %d\n", shared->sum);printf("Sum is %d\n", shared->sum);

}}

Tmk_exit(0);Tmk_exit(0);

}}

Page 33: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 3333

Protocolos de consistenciaProtocolos de consistencia

Entrada (entry)Entrada (entry) Las variables compartidas (o grupo de variables Las variables compartidas (o grupo de variables

compartidas) están protegidas por una variable de compartidas) están protegidas por una variable de sincronización (una sección crítica está limitada por un sincronización (una sección crítica está limitada por un par de accesos a la variable de sincronización).par de accesos a la variable de sincronización).

Se pasarán las variables actualizadas por la red cuando Se pasarán las variables actualizadas por la red cuando sean absolutamente necesarias para las siguientes sean absolutamente necesarias para las siguientes secciones críticas.secciones críticas.

Semejante aproximación lleva a prestaciones Semejante aproximación lleva a prestaciones potencialmente mejores. Sin embargo, las prestaciones potencialmente mejores. Sin embargo, las prestaciones concretas dependen de los detalles de la aplicación.concretas dependen de los detalles de la aplicación.

Page 34: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 3434

Protocolos de consistenciaProtocolos de consistencia

Entry consistencyEntry consistency Midway (sw)Midway (sw)

Protocolo de escritor único que usa actualizaciónProtocolo de escritor único que usa actualización Entry consistency garantiza que los datos compartidos sólo se Entry consistency garantiza que los datos compartidos sólo se

hacen consistentes cuando el procesador adquiere un objeto de hacen consistentes cuando el procesador adquiere un objeto de sincronización.sincronización.

Las ventajas de la consistencia de entrada pueden ser difíciles Las ventajas de la consistencia de entrada pueden ser difíciles de obtener con un esfuerzo limitado en la programación de obtener con un esfuerzo limitado en la programación

Por consiguiente, además de entry consistency, Midway soporta Por consiguiente, además de entry consistency, Midway soporta también liberación y consistencia del procesador.también liberación y consistencia del procesador.

P1W(x) REL(S1)

AC Q (S1) W(x) REL(S1) X S1

Y S2

sig nific a p ro te g id o p o r

NO

AC Q (S2) W(y) REL(S2)

t

t

t

P2

P3

Page 35: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 3535

Protocolos de consistenciaProtocolos de consistencia

Automatic Update Release Consistency (AURC)Automatic Update Release Consistency (AURC) SHRIMP SHRIMP (Scalable High-performance Really Inexpensive Multi-Processor)(Scalable High-performance Really Inexpensive Multi-Processor)

El mecanismo de actualización hardware funciona punto a El mecanismo de actualización hardware funciona punto a puntopunto

Cuando un nodo escribe, sólo se actualiza un nodo remoto Cuando un nodo escribe, sólo se actualiza un nodo remoto (el home).(el home).

El nodo home es aquel que escribió primero en la página.El nodo home es aquel que escribió primero en la página.En los puntos de acquire se envía un mensaje al último En los puntos de acquire se envía un mensaje al último

propietario del lock (a través del home del lock).propietario del lock (a través del home del lock).El nodo adquisitor obtiene los "write notices" junto con el El nodo adquisitor obtiene los "write notices" junto con el

lock.lock. Los "write notices" indican todas las páginas que fueron Los "write notices" indican todas las páginas que fueron

actualizadas en el pasado de ese acquire de acuerdo con el actualizadas en el pasado de ese acquire de acuerdo con el orden parcial sucedió-primero.orden parcial sucedió-primero.

Las páginas indicadas en el "write notice" son invalidadas, a Las páginas indicadas en el "write notice" son invalidadas, a menos que las versiones locales sean posteriores.menos que las versiones locales sean posteriores.

Cuando una página falla se envía una petición al home Cuando una página falla se envía una petición al home indicando la versión.indicando la versión.

Page 36: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 3636

Protocolos de consistenciaProtocolos de consistencia

Automatic Update Release Consistency (AURC)Automatic Update Release Consistency (AURC) Cont.Cont.

El home mantiene el "copy set" (lista de nodos que El home mantiene el "copy set" (lista de nodos que comparten la página) y el "vector de versiones" actualizado comparten la página) y el "vector de versiones" actualizado (que locks escribieron en una determinada versión de la (que locks escribieron en una determinada versión de la página).página).

Cada nodo mantiene una copia del elemento del vector de Cada nodo mantiene una copia del elemento del vector de versiones que le atañe. Relacionado con las páginas versiones que le atañe. Relacionado con las páginas replicadas en ese nodo.replicadas en ese nodo.

Cuando al home le llega una petición de página (por un fallo Cuando al home le llega una petición de página (por un fallo remoto).remoto).

Si tiene al menos la versión requerida: contesta.Si tiene al menos la versión requerida: contesta. Si no: espera hasta conseguir la versión o posterior.Si no: espera hasta conseguir la versión o posterior.

Page 37: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 3737

Protocolos de consistenciaProtocolos de consistencia

Automatic Update Release Consistency (AURC)Automatic Update Release Consistency (AURC) Cont.Cont.

Cuando llega al nodo la página que ha fallado se protege para Cuando llega al nodo la página que ha fallado se protege para escritura y se despierta al proceso que generó el fallo.escritura y se despierta al proceso que generó el fallo.

La primera escritura en la página después del acquire La primera escritura en la página después del acquire generará un fallo de escritura, que se utilizará para añadir la generará un fallo de escritura, que se utilizará para añadir la página a la "lista de actualizaciones" y desprotegerla.página a la "lista de actualizaciones" y desprotegerla.

Cada escritura es realizada sobre la copia local y propagada Cada escritura es realizada sobre la copia local y propagada (hw) al home.(hw) al home.

El resto de nodos serán actualizados cuando adquieran el El resto de nodos serán actualizados cuando adquieran el lock y contacten con el home para obtener la última lock y contacten con el home para obtener la última actualización de la páginaactualización de la página

En el punto de release el nodo incrementa su timestamp local En el punto de release el nodo incrementa su timestamp local y lo envía a todos los homes de las páginas de su "lista de y lo envía a todos los homes de las páginas de su "lista de actualizaciones" para que actualicen el vector de versiones, actualizaciones" para que actualicen el vector de versiones, al mismo tiempo que se vacían los enlaces entre el nodo y los al mismo tiempo que se vacían los enlaces entre el nodo y los homes. Se protegen para escritura todas las páginas y se homes. Se protegen para escritura todas las páginas y se vacía la "lista de actualizaciones".vacía la "lista de actualizaciones".

Page 38: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 3838

Protocolos de consistenciaProtocolos de consistencia

Automatic Update Release Consistency (AURC)Automatic Update Release Consistency (AURC)Copyset-2. comunicación punto a punto hardware entre el Copyset-2. comunicación punto a punto hardware entre el

nodo de escritura y el nodo dueño de la página escritanodo de escritura y el nodo dueño de la página escritaCopyset-N . Modelo de comunicaciones más general. Copyset-N . Modelo de comunicaciones más general.

P1

ACQ

AuUp

ACQ R(x)

Copy2Copy1

ACQ

W(x)

Flush

REL

t x

t

t

P2

P3

xREL

Page 39: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 3939

Protocolos de consistenciaProtocolos de consistencia

Automatic Update Release Consistency (AURC)Automatic Update Release Consistency (AURC)P1

A CQ

A C Q

A C Q

W (x )

R dF t

R E L

R EL

R (x )t

t

t

P2

P3

A C Q C o p y 2

O W N E R

C op y N -1C op y 1

A C Q

R d F t R ( x )

W ( x ) R E L

R E L

t

t

x

x

t

t

P 1

P 0

P 2

P 3

x

A C Q

P1

ACQ

AuUp

ACQ R(x)

Copy2Copy1

ACQ

W(x)

Flush

REL

t x

t

t

P2

P3

xREL

Page 40: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 4040

Protocolos de consistenciaProtocolos de consistencia

Scope consistency (ScC)Scope consistency (ScC) SHRIMP SHRIMP (Scalable High-performance Really Inexpensive Multi-Processor)(Scalable High-performance Really Inexpensive Multi-Processor), ,

idéntico a AURC excepto:idéntico a AURC excepto:Noticias de escritura mantenidas por lock, no por procesadorNoticias de escritura mantenidas por lock, no por procesadorEl vector de actualización de versiones en el home incluye El vector de actualización de versiones en el home incluye

campos (para cada lock) indicando qué variables fueron campos (para cada lock) indicando qué variables fueron escritas; esto se repite para cada versión de la página.escritas; esto se repite para cada versión de la página.

En la adquisición, el nodo recibe del que libera solo las En la adquisición, el nodo recibe del que libera solo las noticias de escritura que corresponden al lock.noticias de escritura que corresponden al lock.

Invalidación de páginas (igual que LRC/AURC). Cuando falla Invalidación de páginas (igual que LRC/AURC). Cuando falla una página se trae del home (igual que AURC).una página se trae del home (igual que AURC).

No se consulta al home en el acquire, sino cuando se invoca No se consulta al home en el acquire, sino cuando se invoca la variable (como en ENTRY)la variable (como en ENTRY)

La actividad de invocar una variable se relaciona con la La actividad de invocar una variable se relaciona con la página entera (diferencia con ENTRY).página entera (diferencia con ENTRY).

Cada nodo mantiene una lista de listas de actualizaciones, Cada nodo mantiene una lista de listas de actualizaciones, una por cada lock (scope) abiertouna por cada lock (scope) abierto

Page 41: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 4141

Protocolos de consistenciaProtocolos de consistencia

Scope consistency (ScC)Scope consistency (ScC) Cont.Cont.

En el release el procesador incrementa su timestamp y el En el release el procesador incrementa su timestamp y el número de época del lock (el núm. de época se utiliza para número de época del lock (el núm. de época se utiliza para determinar qué write notices enviar al siguiente acquire).determinar qué write notices enviar al siguiente acquire).

En tiempo de barrera se actualizan todas las write notices En tiempo de barrera se actualizan todas las write notices desde la última barrera (scope global). Lo que asegura que desde la última barrera (scope global). Lo que asegura que cuando se alcanza la barrera todo el espacio de direcciones cuando se alcanza la barrera todo el espacio de direcciones se hace coherente.se hace coherente.

Page 42: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 4242

Protocolos de consistenciaProtocolos de consistencia

Implementaciones DSM Implementaciones DSM (hw-mayormente vs sw-mayormente )(hw-mayormente vs sw-mayormente )::

Sequential: MEMNET+KSR1 vs. IVY+MIRAGE

Delp/Farber(Delaware)+Frank(KSR) vs. Li(Yale)+Fleish/Popek(UCLA)

Processor: RM vs. PLUS

Gould/Encore/DEC(USA) vs. Bisiani/Ravishankar/Nowatzyk(CMU)

Weak: TSO vs. DSB

SUN/HAL/SGI(USA) vs. Dubois/Scheurich/Briggs(USC)

Release: Stanford-DASH vs. Eager-MUNIN

Gharachorloo/Gupta/Hennessy(SU) vs. Carter/Bennett/Zwaenopoel(Rice)

LazyRel: AURC vs. TREADMARKS

Iftode/Dubnicki/Li(Princeton) vs. Zwaenopoel/Keleher/Cox(Rice)

Entry: SCOPE vs. MIDWAY

Iftode/Singh/Li(Princeton) vs. Bershad/Zekauskas/Sawdon(CMU)

Page 43: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 4343

DASHDASH

Origen y Entorno Origen y Entorno LENOSKI + LAUDON + GHARACHORLOO + WEBER + LENOSKI + LAUDON + GHARACHORLOO + WEBER +

GUPTA + HENNESSY + HOROWITZ + LAM GUPTA + HENNESSY + HOROWITZ + LAM Universidad de StanfordUniversidad de Stanford

El sistema: El sistema: nodonodo

SG 4D/340 (4 Proc., 2-niveles cache local, memoria)SG 4D/340 (4 Proc., 2-niveles cache local, memoria)+ tarjetas (controladora de directorio, interface de la red) + tarjetas (controladora de directorio, interface de la red)

dos mallas 2-D wormhole (petición + respuesta) dos mallas 2-D wormhole (petición + respuesta) prototipo: 16 nodos prototipo: 16 nodos memoria compartido particionadamemoria compartido particionada protocolo de coherencia cache distribuido por directorioprotocolo de coherencia cache distribuido por directorio

Referencia: Referencia: Lenoski, D., et al., "The Stanford DASH Multiprocessor," Lenoski, D., et al., "The Stanford DASH Multiprocessor,"

IEEE Computer, Vol. 25, No. 3, March 1992, pp. 63-79. IEEE Computer, Vol. 25, No. 3, March 1992, pp. 63-79.

Page 44: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 4444

DASHDASH

Memoria distribuída con un solo espacio de Memoria distribuída con un solo espacio de dirección y un protocolo de coherencia de cache dirección y un protocolo de coherencia de cache basado en directoriobasado en directorio

. . .

. . .

M

C 2C 2

C 1C 1

P P

N I

D

N N

Tw o 2-D m eshes Granularidad: bloque de Granularidad: bloque de cache (16 bytes) cache (16 bytes)

Cada bloque tiene su Cada bloque tiene su home cluster:home cluster: el lugar físicoel lugar físico + entrada de directorio + entrada de directorio

correspondiente correspondiente

Page 45: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 4545

DASHDASH

Jerarquía de memoria: 4 nivelesJerarquía de memoria: 4 niveles1. el cache de procesador 1. el cache de procesador 2. las caches de otros procesadores del cluster local 2. las caches de otros procesadores del cluster local 3. el cluster de home 3. el cluster de home 4. el cluster remoto 4. el cluster remoto

Protocolo de coherencia Protocolo de coherencia Directorio distribuido completamente mapeado Directorio distribuido completamente mapeado Basado en invalidación Basado en invalidación

Entrada del directorio:Entrada del directorio: vector de bits de presencia + bit de sucio + bits de estado vector de bits de presencia + bit de sucio + bits de estado

Estados: Estados: uncached: no cacheado por ningún otro cluster uncached: no cacheado por ningún otro cluster shared: copias cacheadas no-modificadasshared: copias cacheadas no-modificadas dirty: modificada la copia en una sola cache de algún dirty: modificada la copia en una sola cache de algún

clustercluster

Page 46: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 4646

DASHDASH

Operación de lectura:Operación de lectura: Si no se satisface dentro del clusterSi no se satisface dentro del cluster

la petición se envía al directorio homela petición se envía al directorio home

Si el bloque está en estado SHARED o UNCACHEDSi el bloque está en estado SHARED o UNCACHEDla petición se satisface por el cluster homela petición se satisface por el cluster homeSi el estado era UNCACHED se cambia a SHARED.Si el estado era UNCACHED se cambia a SHARED.

Si el bloque está en estado DIRTYSi el bloque está en estado DIRTYla petición se reenvía al cluster remotola petición se reenvía al cluster remotola petición se satisface por el cluster remotola petición se satisface por el cluster remotose envía un mensaje de escritura al cluster homese envía un mensaje de escritura al cluster homeel cluster home actualiza el estado a sharedel cluster home actualiza el estado a shared

Page 47: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 4747

DASHDASH

Operación de escritura:Operación de escritura: Petición de lectura exclusiva al cluster homePetición de lectura exclusiva al cluster home Si el bloque está SHAREDSi el bloque está SHARED

El cluster home satisface la peticiónEl cluster home satisface la peticiónEl cluster home cambia el estado a DIRTYEl cluster home cambia el estado a DIRTYEl cluster home envía invalidaciones a las copias El cluster home envía invalidaciones a las copias

compartidascompartidasLos clusters en sahed envían reconocimientos de Los clusters en sahed envían reconocimientos de

invalidación al cluster que hizo la peticióninvalidación al cluster que hizo la petición

Si el bloque está DIRTYSi el bloque está DIRTYEl cluster home retransmite la petición al cluster remotoEl cluster home retransmite la petición al cluster remotoEl cluster remoto satisface la petición.El cluster remoto satisface la petición.

Page 48: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 4848

DASHDASH

Diagrama de bloques de las tarjetasDiagrama de bloques de las tarjetas

Reply Controller (RC)Reply Controller (RC)•Remote Access Cache Remote Access Cache (RAC) almacena el estado (RAC) almacena el estado de las peticiones de de las peticiones de memoria pendientes y las memoria pendientes y las respuestas remotasrespuestas remotas•Contadores de invalidación Contadores de invalidación por procesadorpor procesador•la RAC husmea en el busla RAC husmea en el bus

Reply Controller (RC)Reply Controller (RC)•Remote Access Cache Remote Access Cache (RAC) almacena el estado (RAC) almacena el estado de las peticiones de de las peticiones de memoria pendientes y las memoria pendientes y las respuestas remotasrespuestas remotas•Contadores de invalidación Contadores de invalidación por procesadorpor procesador•la RAC husmea en el busla RAC husmea en el bus

Pseudo-CPU (PCPU)Pseudo-CPU (PCPU)•Retranmite las peticiones Retranmite las peticiones remotas al MPbusremotas al MPbus•Genera invalidaciones de Genera invalidaciones de líneas de cache y bloqueo líneas de cache y bloqueo de premisosde premisos

Pseudo-CPU (PCPU)Pseudo-CPU (PCPU)•Retranmite las peticiones Retranmite las peticiones remotas al MPbusremotas al MPbus•Genera invalidaciones de Genera invalidaciones de líneas de cache y bloqueo líneas de cache y bloqueo de premisosde premisos

Encaminador Rply Encaminador Rply dimensión Ydimensión Y

Encaminador Rply Encaminador Rply dimensión Ydimensión Y

Encaminador Rply Encaminador Rply dimensión Ydimensión Y

Encaminador Rply Encaminador Rply dimensión Ydimensión Y

Directory Controller (DC)Directory Controller (DC)•Directorio DRAMDirectorio DRAM•Retranmite las peticiones Retranmite las peticiones locales a clusters remotoslocales a clusters remotos•Responde petic. remotasResponde petic. remotas•Responde al Mpbus con Responde al Mpbus con información del directorioinformación del directorio•Almacena bloqueos y colas Almacena bloqueos y colas de bloqueosde bloqueos

Directory Controller (DC)Directory Controller (DC)•Directorio DRAMDirectorio DRAM•Retranmite las peticiones Retranmite las peticiones locales a clusters remotoslocales a clusters remotos•Responde petic. remotasResponde petic. remotas•Responde al Mpbus con Responde al Mpbus con información del directorioinformación del directorio•Almacena bloqueos y colas Almacena bloqueos y colas de bloqueosde bloqueos

Monitor de PrestacionesMonitor de Prestaciones•Cuentas, distribuciones y Cuentas, distribuciones y trazas del bus, red y eventos trazas del bus, red y eventos internos.internos.

Monitor de PrestacionesMonitor de Prestaciones•Cuentas, distribuciones y Cuentas, distribuciones y trazas del bus, red y eventos trazas del bus, red y eventos internos.internos.

Encaminador Rply Encaminador Rply dimensión Xdimensión X

Encaminador Rply Encaminador Rply dimensión Xdimensión X

Encaminador Rply Encaminador Rply dimensión Xdimensión X

Encaminador Rply Encaminador Rply dimensión Xdimensión X

Respuestas a Respuestas a clusters Y ± 1clusters Y ± 1Respuestas a Respuestas a clusters Y ± 1clusters Y ± 1

Peticiones a Peticiones a clusters Y ± 1clusters Y ± 1Peticiones a Peticiones a

clusters Y ± 1clusters Y ± 1Respuestas a Respuestas a clusters X ± 1clusters X ± 1Respuestas a Respuestas a clusters X ± 1clusters X ± 1

Peticiones a Peticiones a clusters X ± 1clusters X ± 1Peticiones a Peticiones a

clusters X ± 1clusters X ± 1

MpbusMpbusDirecciones, ControlDirecciones, Control

y Datosy Datos

MpbusMpbusDirecciones, ControlDirecciones, Control

y Datosy Datos

Reply ControllerReply Controller(RC) board(RC) board

Reply ControllerReply Controller(RC) board(RC) board

Directory Directory ControllerController(DC) board(DC) board

Directory Directory ControllerController(DC) board(DC) board

Page 49: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 4949

DASHDASH

Petición de lectura de un bloque DIRTYPetición de lectura de un bloque DIRTY

•Una CPU genera una lectura en el bus Una CPU genera una lectura en el bus y es forzada a reintentary es forzada a reintentar•Se genera una nueva entrada en la RACSe genera una nueva entrada en la RAC•DC envía una Read-Req al homeDC envía una Read-Req al home

•Una CPU genera una lectura en el bus Una CPU genera una lectura en el bus y es forzada a reintentary es forzada a reintentar•Se genera una nueva entrada en la RACSe genera una nueva entrada en la RAC•DC envía una Read-Req al homeDC envía una Read-Req al home

•La PCPU genera una lectura en el busLa PCPU genera una lectura en el bus•La entrada en el directorio está en DIRTYLa entrada en el directorio está en DIRTY•DC retransmite una Read-Req al cluster dirtyDC retransmite una Read-Req al cluster dirty

•La PCPU genera una lectura en el busLa PCPU genera una lectura en el bus•La entrada en el directorio está en DIRTYLa entrada en el directorio está en DIRTY•DC retransmite una Read-Req al cluster dirtyDC retransmite una Read-Req al cluster dirty

•La PCPU genera una lectura en el busLa PCPU genera una lectura en el bus•La cache dirty responde con los datosLa cache dirty responde con los datos•DC envía una Read-Rply al cluster localDC envía una Read-Rply al cluster local•DC envía una Sharing-Writeback al cluster homeDC envía una Sharing-Writeback al cluster home

•La PCPU genera una lectura en el busLa PCPU genera una lectura en el bus•La cache dirty responde con los datosLa cache dirty responde con los datos•DC envía una Read-Rply al cluster localDC envía una Read-Rply al cluster local•DC envía una Sharing-Writeback al cluster homeDC envía una Sharing-Writeback al cluster home

•La PCPU genera Sharing-Writeback en el La PCPU genera Sharing-Writeback en el busbus•DC actualiza la entrada del directorio al DC actualiza la entrada del directorio al estado sharedestado shared

•La PCPU genera Sharing-Writeback en el La PCPU genera Sharing-Writeback en el busbus•DC actualiza la entrada del directorio al DC actualiza la entrada del directorio al estado sharedestado shared

•RC obtiene la Read-Rply y libera la RC obtiene la Read-Rply y libera la CPUCPU•La CPU reintenta la lectura y la RAC La CPU reintenta la lectura y la RAC responde con los datosresponde con los datos

•RC obtiene la Read-Rply y libera la RC obtiene la Read-Rply y libera la CPUCPU•La CPU reintenta la lectura y la RAC La CPU reintenta la lectura y la RAC responde con los datosresponde con los datos

1111

2222

3a3a3a3a 3b3b3b3b

Cluster LocalCluster LocalCluster LocalCluster Local

Cluster HomeCluster HomeCluster HomeCluster Home

Cluster DirtyCluster DirtyCluster DirtyCluster Dirty

Read-Req al homeRead-Req al homeRead-Req al homeRead-Req al home

Read-Req al dirtyRead-Req al dirtyRead-Req al dirtyRead-Req al dirty

Read-Rply al localRead-Rply al localRead-Rply al localRead-Rply al localSharing-Writeback al homeSharing-Writeback al homeSharing-Writeback al homeSharing-Writeback al home

Page 50: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 5050

DASHDASH

Petición de escritura de un bloque SHAREDPetición de escritura de un bloque SHARED

•El buffer de escritura de la CPU genera El buffer de escritura de la CPU genera una lectura-exclusiva en el bus y es una lectura-exclusiva en el bus y es forzado a reintentarforzado a reintentar•Se genera una nueva entrada en la RACSe genera una nueva entrada en la RAC•DC envía una Read-Ex-Req al homeDC envía una Read-Ex-Req al home

•El buffer de escritura de la CPU genera El buffer de escritura de la CPU genera una lectura-exclusiva en el bus y es una lectura-exclusiva en el bus y es forzado a reintentarforzado a reintentar•Se genera una nueva entrada en la RACSe genera una nueva entrada en la RAC•DC envía una Read-Ex-Req al homeDC envía una Read-Ex-Req al home

•La PCPU genera una lectura-excl en el busLa PCPU genera una lectura-excl en el bus•La entrada en el directorio está en SHAREDLa entrada en el directorio está en SHARED•DC envía una Read-Ex-Rply con la cuenta de DC envía una Read-Ex-Rply con la cuenta de invalidación al cluster localinvalidación al cluster local•DC envía una Inv-Req a los cluster sharedDC envía una Inv-Req a los cluster shared•DC actualiza el estado a DIRTYDC actualiza el estado a DIRTY

•La PCPU genera una lectura-excl en el busLa PCPU genera una lectura-excl en el bus•La entrada en el directorio está en SHAREDLa entrada en el directorio está en SHARED•DC envía una Read-Ex-Rply con la cuenta de DC envía una Read-Ex-Rply con la cuenta de invalidación al cluster localinvalidación al cluster local•DC envía una Inv-Req a los cluster sharedDC envía una Inv-Req a los cluster shared•DC actualiza el estado a DIRTYDC actualiza el estado a DIRTY

•La PCPU genera una lectura-excl. en el bus para La PCPU genera una lectura-excl. en el bus para invalidar las copias compartidasinvalidar las copias compartidas•DC envía una Inv-Ack al cluster localDC envía una Inv-Ack al cluster local

•La PCPU genera una lectura-excl. en el bus para La PCPU genera una lectura-excl. en el bus para invalidar las copias compartidasinvalidar las copias compartidas•DC envía una Inv-Ack al cluster localDC envía una Inv-Ack al cluster local

•La cuenta de inv. de la entrada de la La cuenta de inv. de la entrada de la RAC se decrementa a cada Inv-AckRAC se decrementa a cada Inv-Ack•Cuando la cuenta llega a 0 se libera la Cuando la cuenta llega a 0 se libera la entrada de la RACentrada de la RAC

•La cuenta de inv. de la entrada de la La cuenta de inv. de la entrada de la RAC se decrementa a cada Inv-AckRAC se decrementa a cada Inv-Ack•Cuando la cuenta llega a 0 se libera la Cuando la cuenta llega a 0 se libera la entrada de la RACentrada de la RAC

1111

2a2a2a2a

Cluster LocalCluster LocalCluster LocalCluster Local

Cluster HomeCluster HomeCluster HomeCluster Home

Clusters RemotosClusters RemotosClusters RemotosClusters Remotos

Read-Ex-Req al homeRead-Ex-Req al homeRead-Ex-Req al homeRead-Ex-Req al home

Read-EXRplyRead-EXRplyal localal local

Read-EXRplyRead-EXRplyal localal local

Inv-Ack al localInv-Ack al localInv-Ack al localInv-Ack al local

•RC recibe Read-Ex-Rply con datos y RC recibe Read-Ex-Rply con datos y cuenta de invalidación y libera la CPUcuenta de invalidación y libera la CPU•El buffer reintenta la lectura-exclusiva El buffer reintenta la lectura-exclusiva y el RAC contesta con los datosy el RAC contesta con los datos•El buffer reintenta la escrituraEl buffer reintenta la escritura

•RC recibe Read-Ex-Rply con datos y RC recibe Read-Ex-Rply con datos y cuenta de invalidación y libera la CPUcuenta de invalidación y libera la CPU•El buffer reintenta la lectura-exclusiva El buffer reintenta la lectura-exclusiva y el RAC contesta con los datosy el RAC contesta con los datos•El buffer reintenta la escrituraEl buffer reintenta la escritura

•La PCPU genera una lectura-excl. en el bus para La PCPU genera una lectura-excl. en el bus para invalidar las copias compartidasinvalidar las copias compartidas•DC envía una Inv-Ack al cluster localDC envía una Inv-Ack al cluster local

•La PCPU genera una lectura-excl. en el bus para La PCPU genera una lectura-excl. en el bus para invalidar las copias compartidasinvalidar las copias compartidas•DC envía una Inv-Ack al cluster localDC envía una Inv-Ack al cluster local

•La PCPU genera una lectura-excl. en el bus para La PCPU genera una lectura-excl. en el bus para invalidar las copias compartidasinvalidar las copias compartidas•DC envía una Inv-Ack al cluster localDC envía una Inv-Ack al cluster local

•La PCPU genera una lectura-excl. en el bus para La PCPU genera una lectura-excl. en el bus para invalidar las copias compartidasinvalidar las copias compartidas•DC envía una Inv-Ack al cluster localDC envía una Inv-Ack al cluster local

2b2b1:n1:n2b2b1:n1:n

331:n1:n33

1:n1:n

Inv-ReqInv-Reqa los shareda los shared

Inv-ReqInv-Reqa los shareda los shared

Page 51: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 5151

DIPC: semáforosDIPC: semáforos

Primitivas de gestión de semáforosPrimitivas de gestión de semáforos Declaración (creación, apertura de uno existente, ...)Declaración (creación, apertura de uno existente, ...)

semget (...)semget (...)

Control (inicialización, consulta, destrucción, ...)Control (inicialización, consulta, destrucción, ...)semctl (...)semctl (...)

OperacionesOperacionessemop (...)semop (...)

Includes necesarios:Includes necesarios: # include <sys/types.h># include <sys/types.h> # include <sys/ipc.h># include <sys/ipc.h> # include <sys/sem.h># include <sys/sem.h>

Page 52: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 5252

DIPC: semgetDIPC: semget

int semget ( key_t key, int nsems, int semflg )int semget ( key_t key, int nsems, int semflg ) ParámetrosParámetros

key: clave de acceso al conjunto de semáforoskey: clave de acceso al conjunto de semáforos nsems: num. de semáforos en el conjuntonsems: num. de semáforos en el conjunto semflg: flags de creaciónsemflg: flags de creación

Retorna:Retorna: un identificador del conjunto de semáforos o error si negativoun identificador del conjunto de semáforos o error si negativo

Ejemplo:Ejemplo:#ifdef#ifdef __GLIBC__ __GLIBC__

#define#define IPC_DIPC 00010000 /*make it distributed*/ IPC_DIPC 00010000 /*make it distributed*/

#endif#endif

#define#define SEM_KEY 31 SEM_KEY 31

#define#define SEM_MODE (IPC_DIPC | IPC_EXCL | 0777) SEM_MODE (IPC_DIPC | IPC_EXCL | 0777)

......

semid = semget(SEM_KEY, 2, SEM_MODE | IPC_CREAT);semid = semget(SEM_KEY, 2, SEM_MODE | IPC_CREAT);

ifif(semid < 0) {(semid < 0) {

fprintf(stderr,"semget() failed BECAUSE %s\n", strerror(errno));fprintf(stderr,"semget() failed BECAUSE %s\n", strerror(errno));

exit(-1);exit(-1);

}}

Page 53: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 5353

DIPC: semctlDIPC: semctl

int semctl (int semctl (int semid, int semnum, int cmd, union semun argint semid, int semnum, int cmd, union semun arg)) ParámetrosParámetros

semid: identificador del conjunto de semáforossemid: identificador del conjunto de semáforos semnum : num. del semáforo en el conjunto empezando por 0semnum : num. del semáforo en el conjunto empezando por 0 cmd: ordencmd: orden arg: argumentos de la ordenarg: argumentos de la orden

Retorna:Retorna: resultado de la operación o error si negativoresultado de la operación o error si negativo

Argumentos:Argumentos:#if !defined(__GNU_LIBRARY__) || defined(_SEM_SEMUN_UNDEFINED)#if !defined(__GNU_LIBRARY__) || defined(_SEM_SEMUN_UNDEFINED)

union semun {union semun {

int val; /* value for SETVAL */int val; /* value for SETVAL */

struct semid_ds *buf; /* buffer for IPC_STAT, IPC_SET */struct semid_ds *buf; /* buffer for IPC_STAT, IPC_SET */

unsigned short int *array; /* array for GETALL, SETALL */unsigned short int *array; /* array for GETALL, SETALL */

struct seminfo *__buf; /* buffer for IPC_INFO */struct seminfo *__buf; /* buffer for IPC_INFO */

};};

#endif#endif

Page 54: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 5454

DIPC: semctlDIPC: semctl

int semctl (int semctl (int semid, int semnum, int cmd, union semun argint semid, int semnum, int cmd, union semun arg)) Ordenes:Ordenes:

cmd = IPC_STATcmd = IPC_STAT Copia en arg.buf la estructura completa del conjuntoCopia en arg.buf la estructura completa del conjunto

cmd = IPC_SETcmd = IPC_SET Copia de arg.buf la estructura completa en el conjuntoCopia de arg.buf la estructura completa en el conjunto

cmd = IPC_RMIDcmd = IPC_RMID Destruye el semáforo y despierta procesos (necesita permisos)Destruye el semáforo y despierta procesos (necesita permisos)

cmd = GETALLcmd = GETALL Retorna en arg.array los valores de todos los semáforos Retorna en arg.array los valores de todos los semáforos

(semval)(semval)

cmd = GETNCTNcmd = GETNCTN Retorna un int con el número de procesos esperando que se Retorna un int con el número de procesos esperando que se

incremente semval del semáforo semnum.incremente semval del semáforo semnum.

cmd = GETPIDcmd = GETPID Retorna un int con el identificador del último proceso que Retorna un int con el identificador del último proceso que

ejecutó un semop sobre el semáforo semnum.ejecutó un semop sobre el semáforo semnum.

Page 55: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 5555

DIPC: semctlDIPC: semctl

int semctl (int semctl (int semid, int semnum, int cmd, union semun argint semid, int semnum, int cmd, union semun arg)) Ordenes:Ordenes:

cmd = GETVALcmd = GETVAL Retorna un int con el valor de semval del semáforo semnum.Retorna un int con el valor de semval del semáforo semnum.

cmd = GETZCNTcmd = GETZCNT Retorna un int con el número de procesos esperando que Retorna un int con el número de procesos esperando que

semval del semáforo semnum tome el valor cero.semval del semáforo semnum tome el valor cero.

cmd = SETALLcmd = SETALL Posiciona los valores de los semáforos de acuerdo con Posiciona los valores de los semáforos de acuerdo con

arg.array, los procesos que esperan "pueden" ser despertados.arg.array, los procesos que esperan "pueden" ser despertados.

cmd = SETVALcmd = SETVAL Posiciona semval del semáforo semnum de acuerdo con arg.val, Posiciona semval del semáforo semnum de acuerdo con arg.val,

los procesos que esperan "pueden" ser despertados.los procesos que esperan "pueden" ser despertados.

Page 56: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 5656

DIPC: semctlDIPC: semctl

int semctl (int semctl (int semid, int semnum, int cmd, union semun argint semid, int semnum, int cmd, union semun arg)) Ejemplo:Ejemplo:

unsigned short seminit[2];unsigned short seminit[2];

......

seminit[0] = seminit[1] = 0;seminit[0] = seminit[1] = 0;

if(semctl(semid, 0, SETALL, (union semun) seminit) < 0) {if(semctl(semid, 0, SETALL, (union semun) seminit) < 0) {

fprintf(stderr,"can't initialize the semaphores BECAUSE %s\n", fprintf(stderr,"can't initialize the semaphores BECAUSE %s\n", strerror(errno));strerror(errno));

exit(-1);exit(-1);

} }

Page 57: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 5757

DIPC: semopDIPC: semop

int semop (int semop (int semid, struct sembuf *sops, unsigned nsopsint semid, struct sembuf *sops, unsigned nsops)) ParámetrosParámetros

semid: identificador del conjunto de semáforossemid: identificador del conjunto de semáforossops: vector de operaciones empezando por 0sops: vector de operaciones empezando por 0nsops: num. de operaciones a realizarnsops: num. de operaciones a realizar

Retorna:Retorna:resultado de la operación o error si negativoresultado de la operación o error si negativo

Cada elemento del struct sembuf incluye:Cada elemento del struct sembuf incluye:short sem_num; /* semaphore number: 0 = first */short sem_num; /* semaphore number: 0 = first */short sem_op; /* semaphore operation */short sem_op; /* semaphore operation */short sem_flg; /* operation flags */short sem_flg; /* operation flags */

Page 58: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 5858

DIPC: semopDIPC: semop

int semop (int semop (int semid, struct sembuf *sops, unsigned nsopsint semid, struct sembuf *sops, unsigned nsops)) OperacionesOperaciones

SiSi sem_op > 0 sem_op > 0 semval = semval + sem_opsemval = semval + sem_op

SiSi sem_op < 0 sem_op < 0 SiSi semval >= abs(sem_op) semval >= abs(sem_op)

semval = semval - abs(sem_op)semval = semval - abs(sem_op) Si noSi no

semncnt = semncnt +1semncnt = semncnt +1 dormir hastadormir hasta semval >= abs(sem_op) semval >= abs(sem_op) semncnt = semncnt -1semncnt = semncnt -1 semval = semval - abs(sem_op)semval = semval - abs(sem_op)

SiSi sem_op = 0 sem_op = 0 Si Si semval <> 0semval <> 0

semzcnt = semzcnt +1semzcnt = semzcnt +1 dormir hasta dormir hasta semval = 0semval = 0 semzcnt = semzcnt -1semzcnt = semzcnt -1

Page 59: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 5959

DIPC: semopDIPC: semop

int semop (int semop (int semid, struct sembuf *sops, unsigned nsopsint semid, struct sembuf *sops, unsigned nsops)) Flags:Flags:

SEM_UNDO: la operación será deshecha cuando el proceso SEM_UNDO: la operación será deshecha cuando el proceso haga exit.haga exit.

IPC_NOWAIT: el proceso no se esperará en el semáforo, en IPC_NOWAIT: el proceso no se esperará en el semáforo, en caso de que hubiera tenido que esperarse se devuelve el caso de que hubiera tenido que esperarse se devuelve el error EAGAINerror EAGAIN

Ejemplo:Ejemplo:struct sembuf sem[2];struct sembuf sem[2];

......

sem[1].sem_num = 1;sem[1].sem_num = 1;

sem[1].sem_op = -1;sem[1].sem_op = -1;

sem[1].sem_flg = SEM_UNDO;sem[1].sem_flg = SEM_UNDO;

if(semop(semid, &sem[1], 1) <0) {if(semop(semid, &sem[1], 1) <0) {printf("mio: semop() failed BECAUSE %s\n", strerror(errno));printf("mio: semop() failed BECAUSE %s\n", strerror(errno));

exit(-1);exit(-1);

}}

Page 60: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 6060

DIPC: mensajesDIPC: mensajes

Primitivas de gestión de mensajesPrimitivas de gestión de mensajes Declaración (creación, apertura de uno existente, ...)Declaración (creación, apertura de uno existente, ...)

msgget (...)msgget (...)

Control (inicialización, consulta, destrucción, ...)Control (inicialización, consulta, destrucción, ...)msgctl (...)msgctl (...)

OperacionesOperacionesmsgsnd (...)msgsnd (...)msgrcv (...)msgrcv (...)

Includes necesarios:Includes necesarios: # include <sys/types.h># include <sys/types.h> # include <sys/ipc.h># include <sys/ipc.h> # include <sys/sem.h># include <sys/sem.h>

Page 61: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 6161

DIPC: msggetDIPC: msgget

int msgget ( key_t key, int msgflg )int msgget ( key_t key, int msgflg ) ParámetrosParámetros

key: clave de acceso a la cola de mensajeskey: clave de acceso a la cola de mensajes msgflg: flags de creaciónmsgflg: flags de creación

Retorna:Retorna: un identificador de la cola de mensajes o error si negativoun identificador de la cola de mensajes o error si negativo

Ejemplo:Ejemplo:#ifdef#ifdef __GLIBC__ __GLIBC__

#define#define IPC_DIPC 00010000 /* make it distributed */ IPC_DIPC 00010000 /* make it distributed */

#endif#endif

#define#define MSG_KEY 40 MSG_KEY 40

#define#define MSG_MODE (IPC_DIPC | IPC_EXCL | 0777) MSG_MODE (IPC_DIPC | IPC_EXCL | 0777)

......

msgid = msgget(MSG_KEY, MSG_MODE | IPC_CREAT);msgid = msgget(MSG_KEY, MSG_MODE | IPC_CREAT);

ifif(msgid < 0) {(msgid < 0) {

fprintf(stderr,"msgget() failed BECAUSE %s\n", strerror(errno));fprintf(stderr,"msgget() failed BECAUSE %s\n", strerror(errno));

exit(20);exit(20);

}}

Page 62: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 6262

DIPC: msgctlDIPC: msgctl

int msgctl (int msqid, int cmd, struct msqid_ds *buf)int msgctl (int msqid, int cmd, struct msqid_ds *buf) ParámetrosParámetros

msqid: identificador de la cola de mensajesmsqid: identificador de la cola de mensajes cmd: ordencmd: orden buf: puntero a estructura de colabuf: puntero a estructura de cola

Retorna:Retorna: error si negativoerror si negativo

Ordenes:Ordenes:cmd = IPC_STATcmd = IPC_STAT

Copia en buf la estructura completa de la colaCopia en buf la estructura completa de la cola

cmd = IPC_SETcmd = IPC_SET Copia de buf la estructura completa en la colaCopia de buf la estructura completa en la cola

cmd = IPC_RMIDcmd = IPC_RMID Destruye la cola y su estructura y despierta procesos (necesita Destruye la cola y su estructura y despierta procesos (necesita

permisos)permisos)

Ejemplo:Ejemplo:msgctl(msgid,IPC_RMID,NULL);msgctl(msgid,IPC_RMID,NULL);

Page 63: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 6363

DIPC: msgctlDIPC: msgctl

int msgctl (int msqid, int cmd, struct msqid_ds *buf)int msgctl (int msqid, int cmd, struct msqid_ds *buf) Estructura de la cola:Estructura de la cola:

struct msqid_dsstruct msqid_ds

{{

struct ipc_perm msg_perm;struct ipc_perm msg_perm; /*structure describing operation permission*//*structure describing operation permission*/

struct msg *__msg_first;struct msg *__msg_first; /*pointer to first message on queue*//*pointer to first message on queue*/

struct msg *__msg_last;struct msg *__msg_last; /*pointer to last message on queue*//*pointer to last message on queue*/

__time_t msg_stime;__time_t msg_stime; /*time of last msgsnd command*//*time of last msgsnd command*/

__time_t msg_rtime;__time_t msg_rtime; /*time of last msgrcv command*//*time of last msgrcv command*/

__time_t msg_ctime;__time_t msg_ctime; /*time of last change*//*time of last change*/

struct wait_queue *__wwait;struct wait_queue *__wwait; /*???*//*???*/

struct wait_queue *__rwait;struct wait_queue *__rwait; /*???*//*???*/

unsigned short int __msg_cbytes; unsigned short int __msg_cbytes; /*current number of bytes on /*current number of bytes on queue*/queue*/

unsigned short int msg_qnum;unsigned short int msg_qnum; /*num of messages currently /*num of messages currently queued*/queued*/

unsigned short int msg_qbytes; /*max number of bytes allowed on queue*/unsigned short int msg_qbytes; /*max number of bytes allowed on queue*/

__ipc_pid_t msg_lspid;__ipc_pid_t msg_lspid; /*pid of last msgsnd()*//*pid of last msgsnd()*/

__ipc_pid_t msg_lrpid;__ipc_pid_t msg_lrpid; /*pid of last msgrcv()*//*pid of last msgrcv()*/

};};

Page 64: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 6464

DIPC: msgsndDIPC: msgsnd

int msgsnd int msgsnd (int msqid, struct msgbuf *msgp, int msgsz, int msgflg)(int msqid, struct msgbuf *msgp, int msgsz, int msgflg)

ParámetrosParámetrosmsqid: identificador de la cola de mensajesmsqid: identificador de la cola de mensajesmsgp: puntero al buffer del mensajemsgp: puntero al buffer del mensajemsgsz: tamaño del mensaje en bytesmsgsz: tamaño del mensaje en bytesmsgflg: comportamiento de la llamadamsgflg: comportamiento de la llamada

SiSi msgsz > msg_qbytes msgsz > msg_qbytes

SiSi msgflg = IPC_NOWAIT msgflg = IPC_NOWAIT

retornaretorna ERROR ERROR

SinoSino

espera hastaespera hasta msgsz <= msgsz <= msg_qbytesmsg_qbytes

Retorna:Retorna:error si negativoerror si negativo

El struct msgbuf incluye:El struct msgbuf incluye:struct msgbuf {struct msgbuf {

long mtype; long mtype; /* message type, must be > 0 *//* message type, must be > 0 */

char mtext[1]; char mtext[1]; /* message data */ };/* message data */ };

Page 65: Memoria Compartida Distribuida José A. Gil Salinas Universidad Politécnica de Valencia Departamento de Informática de Sistemas y Computadores

© José A. Gil© José A. Gil 6565

DIPC: msgsndDIPC: msgsnd

int msgsnd int msgsnd (int msqid, struct msgbuf *msgp, int msgsz, int msgflg)(int msqid, struct msgbuf *msgp, int msgsz, int msgflg)

Ejemplo:Ejemplo:#define MSG_TYPE 10#define MSG_TYPE 10

#define MSG_SIZE 512#define MSG_SIZE 512

struct message {struct message {

long mtype;long mtype;

char mtext[MSG_SIZE]; };char mtext[MSG_SIZE]; };

struct message mess;struct message mess;

......

mess.mtype = MSG_TYPE; /* not necessary here */mess.mtype = MSG_TYPE; /* not necessary here */

strcpy(mess.mtext,"Hello, Distributed Programming!");strcpy(mess.mtext,"Hello, Distributed Programming!");

if(msgsnd(msgid, (struct msgbuf *)&mess, sizeof(mess.mtext), 0) < 0) {if(msgsnd(msgid, (struct msgbuf *)&mess, sizeof(mess.mtext), 0) < 0) {

fprintf(stderr,"msgsnd() failed BECAUSE %s\n", strerror(errno));fprintf(stderr,"msgsnd() failed BECAUSE %s\n", strerror(errno));

exit(20);exit(20);

}}