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
© 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
© 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.
© 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
© José A. Gil© José A. Gil 55
Estructura y organización de un sistema DSMEstructura y organización de un sistema DSM
© 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).
© 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
© 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
© 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
© 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)
© 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
© 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.
© 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
© 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.
© 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
© 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.)
© 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.)
© 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.
© 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.
© 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).
© 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.
© 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
© 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).
© 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
© 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
© 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
© 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
© 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);
......
© 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);
......
© 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);
......
© 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);
}}
......
© 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);
}}
© 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.
© 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
© 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.
© 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.
© 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".
© 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
© 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
© 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
© 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.
© 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)
© 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.
© 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
© 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
© 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
© 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.
© 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
© 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
© 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
© 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>
© 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);
}}
© 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
© 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.
© 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.
© 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);
} }
© 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 */
© 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
© 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);
}}
© 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>
© 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);
}}
© 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);
© 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()*/
};};
© 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 */ };
© 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);
}}