Tema 2 Comunicación y sincronización entre procesos
|
|
- Elisa Flores Pinto
- hace 7 años
- Vistas:
Transcripción
1 Tema 2 Comunicación y sincronización entre procesos Grupo ARCOS Grado en Ingeniería Informática Universidad Carlos III de Madrid
2 Contenido Repaso de los conceptos de proceso y threads Concurrencia Mecanismos de comunicación Mecanismos de sincronización Llamadas al sistema de POSIX para comunicación y sincronización de procesos Paso de mensajes 2
3 Bibliografía Bibliografía básica: Sistemas Operativos: una visión aplicada. Por Jesús Carretero, Félix García, Pedro de Miguel y Fernando Pérez Mc. Graw-Hill Prácticas de Sistemas Operativos: de la base al diseño Por Jesús Carretero, Félix García, Pedro de Miguel y Fernando Pérez Mc. Graw-Hill 3
4 Sistema Distribuido Sistema compuesto por recursos de computación (hardware y software) físicamente distribuidos e interconectados a través de una red, que son capaces de colaborar con el fin de realizar una determinada tarea La espina dorsal de Red los sistemas distribuidos son los mecanismos de comunicación entre procesos (IPC) 4
5 Conceptos previos Un programa es un conjunto de instrucciones Un proceso es un programa en ejecución Una red de computadores es un conjunto de computadores conectados por una red de interconexión Un sistema distribuido es un conjunto de computadores (sin memoria ni reloj común) conectados por una red Aplicaciones distribuidas: conjunto de procesos que ejecutan en uno o más computadores que colaboran y comunican intercambiando mensajes Un protocolo es un conjunto de reglas e instrucciones que gobiernan la comunicación en un sistema distribuido, es decir, el intercambio y formato de los mensajes 5
6 Sistema Operativo Gestión de los recursos del computador Ejecución de servicios para los programas en ejecución Ejecución de los mandatos de los usuarios Usuarios Procesos de usuario Shell Servicios Núcleo Hardware API Sistema operativo 6
7 Componentes del Sistemas Operativo Objetivo Tema 2 Objetivo Tema 2 Usuarios Programas de usuario Shell 1 Shell 2 Gestión de procesos Interfaz de llamadas al SO Gestión de memoria Gestión de la E/S Núcleo Hardware Gestión de archivos y directorios Seguridad y protección Comunicac. y sincroniz. Sistema operativo 7
8 Proceso Definición Programa en ejecución Unidad de procesamiento gestionada por el SO Para que un programa pueda ser ejecutado ha de residir en memoria principal Árbol de procesos Proc. Inic. Relación de jerarquía Inicio Inicio Inicio Inicio Dem. Impr. Dem. Com.. Shell Shell Editor Proceso A Proceso B Proceso D Proceso C Proceso E Proceso F 8
9 Información de los procesos El sistema operativo mantiene un conjunto de estructuras de información que permiten identificar y gestionar los procesos Registros especiales Mapa de memoria del Proceso A Registros generales PC SP Estado Mapa de memoria del Proceso B Mapa de memoria del Proceso C Tablas SO Mapa de Memoria Tablas del sistema operativo Tabla de procesos BCP Proceso A BCP Proceso B BCP Proceso C - Estado (registros) - Estado (registros) - Estado (registros) - Identificación - Control - Identificación - Control - Identificación - Control - Tabla de memoria - Tabla de E/S - Tabla de ficheros 9
10 Proceso monothread o multithread Un proceso ligero, hilo o thread es un programa en ejecución (flujo de ejecución) que comparte la imagen de memoria (y otras informaciones) con otros procesos ligeros Dependiendo del número de procesos que puedan ejecutar simultáneamente, un SO es monotarea o multitarea Un proceso ligero puede contener un solo flujo de ejecución (monothread) o más (multithread) Por ejemplo, en el lenguaje C el hilo de ejecución primario se corresponde con la función principal main Proceso 10 Procesos ligeros
11 Información propia/compartida Por thread (información propia) Contador de programa, Registros Pila Estado (ejecutando, listo o bloqueado) Por proceso (información compartida) Espacio de memoria Variables globales Ficheros abiertos Procesos hijos Temporizadores Señales y semáforos Contabilidad 11
12 Estructura de un proceso con threads Proceso Código Datos Recursos (ficheros,...) Entorno del proceso Hilo 1 Registros Pila Hilo n Registros Pila 12
13 Mapa de memoria de un proceso con threads Mapa de memoria Código Datos con valor inicial Fichero ejecutable Datos sin valor inicial Heap Fichero Fichero proyectado F Zona de memoria compartida Código biblioteca dinámica B Bibliotecas Pila de thread 1 Swap Pila del thread n 13
14 Estados del proceso ligero Como los procesos convencionales, un proceso ligero puede estar en varias situaciones o estados: ejecutando, listo o bloqueado El estado del proceso será la combinación de los estados de sus procesos ligeros. Proceso Bloqueado por comunicación Bloqueado por acceso a disco Activo Procesos ligeros 14
15 Threads y paralelismo Los procesos ligeros permiten paralelizar una aplicación Un programa puede dividirse en procedimientos que pueden ejecutar de manera independiente mediante procesos ligeros Los procesos ligeros pueden lanzar su ejecución de manera simultánea Diseño modular de la aplicación La base del paralelismo: Mantener algún proceso ligero siempre en estado de ejecución: mientras que un proceso está bloqueado otro podría estar ejecutando main(){ main(){ function1(args); function2(args); } Diseño secuencial lanzar_thread( function1(args)); lanzar_thread( } function2(args)); Diseño paralelo 15
16 Ejemplo: ejecución serie vs. paralela Procedimiento 1 P Espera en E/S F Procedimiento 2 P Espera en E/S F Ejecución serie Procedimiento 1 P Procedimiento 2 Espera en E/S F Ejecución paralela P Espera en E/S F Procesamiento 16
17 Programación concurrente En SSOO multitarea pueden coexisitir varios procesos activos a la vez Multiprogramación con un único procesador Multiprocesador Multicomputadora En general, para p procesadores y n procesos, la concurrencia es: Aparente si n>p real si n<=p 17
18 Comunicación entre procesos Proceso de Usuario Proceso de Usuario Proceso de Usuario Proceso de Usuario SO SO SO Un computador Dos computadores 18
19 Ejemplo: Servidores concurrentes con threads Los procesos concurrentes deben comunicar y sincronizarse Cliente petición servidor Cliente Petición/respuesta Crea thread de servicio Cliente servidor respuesta Thread de servicio Cliente Recurso Diseño concurrente Diseño secuencial 19
20 Diseño de servidores mediante threads Distintas arquitecturas de SW para construir servidores paralelos: Un proceso distribuidor que acepta peticiones y las distribuye entre un pool de procesos ligeros Cada proceso ligero realiza las mismas tareas: aceptar peticiones, procesarlas y devolver su resultado Segmentación: cada trabajo se divide en una serie de fases, cada una de ellas se procesa por un proceso ligero especializado Distribuidor Trabajador Núcleo E/S Solicitudes Núcleo E/S Solicitudes Núcleo E/S Solicitudes 20
21 Programación con procesos ligeros Servicios UNIX incluyen: Operaciones de gestión Creación e identificación de procesos ligeros Atributos de un proceso ligero Planificación de procesos ligeros Prioridades, políticas de planificación Terminación de procesos ligeros 21
22 Creación e identificación de threads Crear un thread: int pthread_create(pthread_t* thread, const pthread_attr_t* attr, void * (*funcion)(void *), void * arg); donde: thread se crea) attr funcion arg devuelve: int Identificador del nuevo thread (se captura cuando Atributos a aplicar al nuevo thread o NULL Función a ejecutar por el thread que es creado Puntero a el/los argumentos del thread Devuelve 0 si éxito o -1 si error Obtener el identificador de un thread: pthread_t pthread_self(void) 22
23 Atributos de un proceso ligero Un hilo se crea con una serie de atributos por defecto Ejemplo: Por defecto, un hilo es joinable o No Independiente Es posible modificar los atributos por defecto del hilo: 23 Inicia un objeto atributo que se puede utilizar para crear nuevos procesos ligeros int pthread_attr_init(pthread_attr_t *attr); Destruye un objeto de tipo atributo int pthread_attr_destroy(pthread_attr_t *attr); Cambiar el estado de terminación (Joinable / Detached) int pthread_attr_setdetachstate( pthread_attr_t *a, int detachstate); Si detachstate es PTHREAD_CREATE_DETACHED el proceso se crea independiente PTHREAD_CREATE_JOINABLE el proceso se crea no independiente Otras atributos: tamaño de pila, planificación, prioridad, etc.
24 Terminación de procesos ligeros Finaliza la ejecución del proceso ligero: int pthread_exit(void *value); Para procesos creados como NO independientes es además necesario: int pthread_join(pthread_t thid, void **value); Espera la terminación del proceso con identificador thid Devuelve en el segundo argumento el valor pasado en pthread_exit. Sólo se puede esperar la terminación de procesos ligeros no independientes (PTHREAD_CREATE_JOINABLE ) 24
25 Ejemplo: Jerarquía de threads Thread A p_create No independiente p_create Thread D p_create Thread C Thread B p_exit p_join p_exit 25
26 Ejemplo I: creación y terminación #include <stdio.h> /* printf */ #include <pthread.h> /* Para threads */ #define NUM_THREADS 10 int funcion(int *idthread){ printf( Thread id = %d\ti=%d:, pthread_self(),*idthread); pthread_exit(null); } int main () { pthread_t arraythread[num_threads]; /* Array de threads */ int i; /* CREAR THREADS */ for(i=0;i<num_threads;i++){ if (pthread_create(&arraythread[i],null,(void *)funcion, &i)==-1) printf( Error al crear proceso ligero\n ); } /* ESPERAR TERMINACIÓN DE THREADS */ for(i=0;i<num_threads;i++) pthread_join (arraythread[i], NULL); exit(0); 26
27 Ejemplo II: Modificar atributos #include <stdio.h> /* printf */ #include <pthread.h> /* Para threads */ #define MAX_THREADS 10 void func(void) { } printf("thread %d \n", pthread_self()); pthread_exit(0); main() { int j; pthread_attr_t attr; pthread_t thid[max_threads]; } 27 pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr,pthread_create_detached); for(j = 0; j < MAX_THREADS; j ++) pthread_create(&thid[j], &attr, func, NULL); sleep(5); pthread_attr_destroy(&attr);
28 Concurrencia Modelos: Multiprogramación en un único procesador Multiprocesador Multicomputador (proceso distribuido) Ventajas: Facilita la programación Acelera los cálculos Posibilita el uso interactivo a múltiples usuarios Mejor aprovechamiento de los recursos 28
29 Monoprocesador vs. Multiprocesador Proceso A Proceso B Proceso C Tiempo Proceso A Proceso B Proceso C CPU 1 CPU 2 Proceso D Tiempo 29
30 Tipos de procesos concurrentes Tipos de procesos: Independientes: su ejecución no requiere la ayuda o cooperación con otros procesos Cooperantes: su ejecución requiere trabajar conjuntamente con otros procesos para realizar una actividad En ambos casos se produce una interacción entre procesos Compiten por recursos Comparten recursos 30
31 Conceptos previos Una condición de carrera es el acceso concurrente a los recursos compartidos sin coordinación Puede producir resultados diferentes a los esperados Una sección crítica (SC) es un fragmento de código en el que los distintos procesos pueden acceder y modificar recursos compartidos Una sección es atómica si se ejecuta por un thread completamente de manera indivisible, de principio a fin, sin que su ejecución se pueda interrumpir por ningún otro thread Tienen una semántica de éxito-o-fallo 31
32 Ejemplo I: Servidor concurrente Distribuidor Cache Núcleo E/S Solicitudes 32
33 Ejemplo II: Acceso a una caché compartida thread principal Petición 1 Petición 2 Update_block() Update_block() Condición de carrera en la sentencia: Update_block Update_block(bloque) { } b = Get_block(); copy(b, bloque); Cache copy(b1, b2){ for (i=0; i<length;i++) *b1++ = *b2++; 33
34 Acceso a una caché compartida thread principal Petición 1 Petición 2 Update_block() Update_block() Condición de carrera en la sentencia: Update_block Update_block(bloque) { } b = Get_block(); copy(b, bloque); Cache copy(b1, b2){ for (i=0; i<length;i++) *b1++ = *b2++; Operación no atómica 34
35 El problema de la sección crítica Sistema compuesto por n procesos Cada uno tiene un fragmento de código: sección crítica Los procesos deben acceder a la SC con exclusividad Estructura general de cualquier mecanismo utilizado para resolver el problema de la sección crítica: Entrada en la sección crítica Código de la sección crítica Salida de la sección crítica Requisitos que debe ofrecer cualquier solución para resolver el problema de la sección crítica: Exclusión mutua Progreso Espera limitada 35
36 Modelos de comunicación y sincronización Modelo productor-consumidor Modelo de lectores-escritores Modelo de acceso a recursos limitados Modelo cliente-servidor 36
37 Modelo productor-consumidor Proceso Productor Proceso Consumidor Flujo de datos Mecanismo de comunicación 37
38 Modelo de lectores-escritores Lector Lector Escritor Lector Escritor Recurso 38
39 Modelo de acceso a recursos limitados Ejemplo: problema de los filósofos comensales 39
40 Modelo cliente-servidor Petición S.O. Proceso cliente Respuesta Proceso servidor 40
41 Comunicación cliente-servidor Muy utilizada en entornos distribuidos (más del 90% de los sistemas distribuidos utilizan la arquitectura clienteservidor) Máquina A petcición Máquina B cliente NÚCLEO respuesta servidor NÚCLEO RED Protocolo típico: petición-respuesta 41
42 Mecanismos de comunicación Ficheros Tuberías (pipes, FIFOS) Variables en memoria compartida Paso de mensajes 42
43 Comunicación mediante archivos Un archivo es un mecanismo que puede emplearse para comunicar procesos Un proceso puede escribir datos y otro puede leerlos Proces o escritor Dato1 Dato2 Dato3 Dato n Proces o lector Fichero compartido 43
44 Comunicación mediante tuberías Una tubería (pipe) es un mecanismo de comunicación y sincronización Comunicación: archivo compartido Sincronización: semántica bloqueante Puede verse como un pseudoarchivo identificado por dos descriptores, uno se usa para leer y el otro para escribir Los servicios utilizados para lectura y escritura de pipes son los mismos que los usados sobre ficheros write Proces o usuario Tubería SO Proces o usuario read 44 Flujo de datos
45 Ejemplo III: Productor-consumidor con tuberías #include <stdio.h> /* printf */ #include <unistd.h> struct elemento dato; /* dato a producir */ int fildes[2]; int main () { if (pipe(fildes)<0){ } printf( Error al crear la tubería); exit(1); if (fork() == 0){ }else{ for (;;){ } for (;;){ } <Producir dato> write (fildes[1], (char*)&dato, sizeof (struct elemento)); read (fildes[0], (char*)&dato, sizeof (struct elemento)); <Consumir dato> } 45
46 Mecanismos de sincronización Señales (asincronismo) Tuberías (pipes, FIFOS) Semáforos Mutex y variables condicionales Paso de mensajes 46
47 Semáforos Un semáforo [Dijkstra, 1965] es un mecanismo de sincronización de procesos que ejecutan en la misma máquina Idea muy simple: Un semáforo es un objeto con un valor entero inicialmente no negativo Dos operaciones atómicas wait signal 47
48 Operaciones sobre semáforos Operación wait wait(s) { s = s - 1; if (s < 0) { <bloquear al proceso> } } s: valor entero asociado al semáforo Estructura para projeger la SC: Operación signal signal(s) { s = s + 1; if (s <= 0) <Desbloquear a un proceso bloqueado por la operacion wait> } } wait(s) Código de la sección crítica signal(s) 48
49 Secciones críticas con semáforos wait(s); /* entrada en la seccion critica */ < seccion critica > signal(s); /* salida de la seccion critica */ El semáforo debe tener valor inicial 1 Valor del semáforo (s) P wait(s) wait(s) wait(s) P 1 P 2 Ejecutando código de la sección crítica Proceso bloqueado en el semáforo desbloquea -1 signal(s) 0 signal(s) desbloquea 1 signal(s) 49
50 Productor-consumidor con semáforos Productor Consumidor 50
51 Ejemplo IV: Productor-consumidor con semáforos #define TAMAÑO_DEL_BUFFER 1024 Productor() { int posicion = 0; for(;;) { Producir un dato; wait(huecos); Consumidor() { int posición = 0; for(;;) { wait(elementos); dato = buffer[posicion]; posicion = (posicion + 1) % TAMAÑO_DEL_BUFFER; } } buffer[posicion] = dato; posicion = (posicion + 1) % TAMAÑO_DEL_BUFFER; signal(elementos); } } signal(huecos); Consumir el dato extraído; 51
52 Ejemplo V: Lectores-escritores con semáforos Lector() { Escritor(){ wait(sem_lectores); n_lectores = n_lectores + 1; if (n_lectores == 1) wait(sem_recurso); signal(sem_lectores); Consultar el recurso compartido } wait(sem_recurso); /*se puede modificar el recurso*/ signal(sem_recurso); } wait(sem_lectores); n_lectores = n_lectores - 1; if (n_lectores == 0) signal(sem_recurso); signal(sem_lectores); 52
53 Mutex Un mutex es un mecanismo de sincronización especialmente indicado para procesos ligeros Se emplean para tener exclusión mutua sobre SC y tener acceso exclusivo a los recursos compartidos Es un semáforo binario (valor inicial 1) con dos operaciones atómicas: lock(m) Intenta bloquear el mutex. Si el mutex ya está bloqueado el proceso se suspende unlock(m) Desbloquear el mutex.si existen procesos bloqueados en el mutex se desbloquea a uno 53
54 Secciones críticas con mutex lock(m); /* entrada en la seccion critica */ < seccion critica > unlock(m); /* salida de la seccion critica */ La operación unlock debe realizarla el proceso ligero que ejecutó lock Thread A Thread B thread ejecutando lock mutex lock mutex thread bloqueado Sección crítica unlock mutex obtiene mutex Punto de sincronización 54
55 Variables condicionales Una variable condicional es una variable de sincronización asociada a un mutex Bloquea o desbloquea el proceso hasta que ocurra algún suceso Conveniente ejecutarlas entre las llamadas lock y unlock Dos operaciones atómicas: c_wait Bloquea al proceso ligero que la ejecuta y libera el mutex c_signal Desbloquea a uno o varios procesos suspendidos en la variable condicional El proceso que se despierta compite de nuevo por el mutex 55
56 Uso de mutex y variables condicionales Thread A lock(m); /* Código de la sección crítica */ while (condición == FALSE) c_wait(c,m); /* Resto la sección crítica */ unlock(m); /* Salida de la SC */ Thread B lock(m); /* Código de la sección crítica */ /* Se modifica la condición */ condición = TRUE; c_signal(c); /* Resto la sección crítica */ unlock(m); /* Salida de la SC */ Thread A Thread B Thread bloqueado esperando unlock lock c_wait unlock mutex lock Adquiere el mutex Thread bloqueado esperando c_signal Se compite por el mutex Adquiere el mutex c_signal unlock 56
57 Uso de mutex y variables condicionales Thread A lock(mutex); /* acceso al recurso */ comprobar las estructuras de datos; while (recurso ocupado) wait(condition, mutex); marcar el recurso como ocupado; unlock(mutex); Thread B lock(mutex); /* acceso al recurso */ marcar el recurso como libre; signal(condition); unlock(mutex); Importante utilizar while 57
58 Ejemplo VI: Productor-consumidor con mutex y variables condicionales Productor() { int pos = 0; for(;;) { < Producir un dato > lock(mutex); /* acceder al buffer */ while (n_elementos == TAMAÑO_DEL_BUFFER) c_wait(lleno, mutex); buffer[pos] = dato; pos = (pos + 1) % TAMAÑO_DEL_BUFFER; n_elementos ++; if (n_elementos == 1) c_signal(vacio); unlock(mutex); } } Consumidor() { int = 0; for(;;) { lock(mutex); } } while (n_elementos == 0) c_wait(vacío, mutex); dato = buffer[pos]; pos = (pos + 1) % TAMAÑO_DEL_BUFFER; n_elementos --; if (n_elementos == (TAMAÑO_DEL_BUFFER - 1)); c_signal(lleno); unlock(mutex); < Consumir el dato > 58
59 Servicios UNIX para mutex Inicializa un mutex int pthread_mutex_init(pthread_mutex_t *mutex, pthread_mutexattr_t * attr); Destruye un mutex int pthread_mutex_destroy(pthread_mutex_t *mutex) ; Intenta obtener el mutex. Bloquea al proceso ligero si el mutex se encuentra adquirido por otro proceso ligero int pthread_mutex_lock(pthread_mutex_t *mutex); Desbloquea el mutex 59 int pthread_mutex_unlock(pthread_mutex_t *mutex);
60 Servicios UNIX para variables condicionales (I) Inicializa una variable condicional int pthread_cond_init(pthread_cond_t*cond, pthread_condattr_t* attr); Destruye una variable condicional int pthread_cond_destroy(pthread_cond_t *cond); Bloquea al proceso ligero y libera el mutex: Suspende al proceso ligero hasta que otro proceso señaliza la variable condicional cond. Automáticamente se libera el mutex. Cuando se despierta el proceso ligero vuelve a competir por el mutex. int pthread_cond_wait(pthread_cond_t*cond, pthread_mutex_t*mutex); 60
61 Servicios UNIX para variables condicionales (II) Desbloquea el/los proceso(s) ligero(s) y libera el mutex int pthread_cond_signal(pthread_cond_t *cond); Se reactivan uno o más de los procesos ligeros que están suspendidos en la variable condicional cond No tiene efecto si no hay ningún proceso ligero esperando (diferente a los semáforos) int pthread_cond_broadcast(pthread_cond_t *cond); Todos los threads suspendidos en la variable condicional cond se reactivan No tiene efecto si no hay ningún proceso ligero esperando 61
62 Ejemplo VII: Productor-consumidor con mutex (I) #define MAX_BUFFER 1024 /* tamanio del buffer */ #define DATOS_A_PRODUCIR /* datos a producir */ pthread_mutex_t mutex; /* mutex para controlar el acceso al buffer compartido */ pthread_cond_t no_lleno; /* controla el llenado del buffer */ pthread_cond_t no_vacio; /* controla el vaciado del buffer */ int n_elementos; /* numero de elementos en el buffer */ int buffer[max_buffer]; /* buffer comun */ int main(int argc, char *argv[]){ pthread_t th1, th2; pthread_mutex_init(&mutex, NULL); pthread_cond_init(&no_lleno, NULL); pthread_cond_init(&no_vacio, NULL); 62
63 Ejemplo VII: Productor-consumidor con mutex (II) pthread_create(&th1, NULL, Productor, NULL); pthread_create(&th2, NULL, Consumidor, NULL); pthread_join(th1, NULL); pthread_join(th2, NULL); pthread_mutex_destroy(&mutex); pthread_cond_destroy(&no_lleno); pthread_cond_destroy(&no_vacio); } return 0; 63
64 Ejemplo VII: Productor-consumidor con mutex (III) void Productor(void) { int dato, i,pos = 0; for(i=0; i<datos_a_producir; i++ ) { dato = i; /* producir dato */ pthread_mutex_lock(&mutex); /* acceder al buffer */ while (n_elementos == MAX_BUFFER)/* si buffer lleno */ pthread_cond_wait(&lleno, &mutex); /* se bloquea*/ buffer[pos] = i; pos = (pos + 1) % MAX_BUFFER; n_elementos = n_elementos + 1; if (n_elementos == 1) pthread_cond_signal(&vacio); /* buffer no vacío*/ } pthread_mutex_unlock(&mutex); } pthread_exit(0); 64
65 Ejemplo VII: Productor-consumidor con mutex (IV) void Consumidor(void) { int dato, i,pos = 0; for(i=0; i<datos_a_producir; i++ ) { pthread_mutex_lock(&mutex); /* acceder al buffer */ while (n_elementos == 0) /* si buffer vacío */ pthread_cond_wait(&vacio, &mutex); /* se bloquea */ dato = buffer[pos]; pos = (pos + 1) % MAX_BUFFER; n_elementos = n_elementos - 1 ; if (n_elementos == MAX_BUFFER - 1); pthread_cond_signal(&lleno);/* buffer no lleno */ pthread_mutex_unlock(&mutex); } printf( Consume %d \n, dato); /* consume dato */ } pthread_exit(0); 65
66 Paso de mensajes: conceptos básicos Mecanismo de comunicación y sincronización de procesos que ejecutan en distintas máquinas En este tipo de comunicación, los procesos intercambian mensajes Entre los procesos que comunican debe existir un enlace de comunicación Dos primitivas básicas: send(destino, mensaje) receive(origen, mensaje) 66
67 Modelo de comunicación Proceso emisor mensaj e Proceso receptor Emisor: send(destino, mensaje) Receptor: receive(origen, mensaje) 67
68 Paso de mensajes: conceptos básicos Computador A Proceso de Usuario Computador B Proceso de Usuario mensaje1 dato mensaje2 SO SO 68
69 Proceso de comunicación Computador A Proceso de Usuario Computador B Proceso de Usuario mensaje1 dato mensaje2 (mensaje1) SO SO 69
70 Proceso de comunicación Computador A Proceso de Usuario Computador B Proceso de Usuario mensaje1 dato mensaje2 (mensaje1) SO SO dato 70
71 Proceso de comunicación Computador A Proceso de Usuario Computador B Proceso de Usuario mensaje1 dato mensaje2 (mensaje1) SO SO dato dato 71
72 Proceso de comunicación Computador A Proceso de Usuario Computador B Proceso de Usuario mensaje1 dato mensaje2 (mensaje1) SO SO dato dato dato 72
73 Proceso de comunicación Computador A Proceso de Usuario Computador B Proceso de Usuario mensaje1 dato mensaje2 (mensaje1) (mensaje2) SO SO dato dato dato 73
74 Proceso de comunicación Computador A Proceso de Usuario Computador B Proceso de Usuario mensaje1 dato dato mensaje2 (mensaje1) (mensaje2) SO SO dato dato dato 74
75 Paso de mensajes: cuestiones de diseño Tamaño del mensaje Longitud fija o variable Flujo de datos Bidireccional, unidireccional Nombrado Comunicación directa send(p, m): envía un mensaje m al proceso P receive(q, m): recibe un mensaje del proceso Q receive (ANY, m): recibe un mensaje de cualquiera Comunicación indirecta Colas de mensajes o puertos Tipos de comunicación (sincronización) Almacenamiento (buffering) Capacidad o no de almacenamiento del enlace de comunicaciones Fiabilidad Representación de datos, aplanamiento 75
76 Paso de mensajes: cuestiones de diseño Nombrado Comunicación indirecta: los datos se envían a estructuras intermedias Puertos: se asocian a un proceso (un único receptor) Ejemplo: sockets Colas de mensajes: múltiples emisores y receptores Ejemplo: Colas de mensajes POSIX Proceso cliente send Proceso cliente receive Proceso cliente send Proceso cliente Puerto mensaje mensaje Cola de mensajes Comunicación con colas de mensajes Comunicación con puertos 76
77 Paso de mensajes: cuestiones de diseño Tipos de comunicación (sincronización) Síncrona, asíncrona (bloqueante, no bloqueante) Proceso A Comunicación síncrona Proceso B Avanza la ejecución enviar Espera Proceso B recibir Proceso A enviar recibir Espera El proceso A espera al B El proceso B espera al A 77
78 Estructura de un servidor secuencial y concurrente Proceso cliente petición Proceso cliente Proceso cliente petición Proceso cliente respuesta Proceso servidor petición respuesta respuesta Proceso hijo Creación del proceso hijo Proceso servidor Creación del proceso hijo petición respuesta Proceso hijo Servidor secuencial Servidor concurrente 78
79 Colas de mensajes UNIX Mecanismo de comunicación y sincronización Nombrado indirecto Asignan a las colas nombres de ficheros Sólo pueden utilizar colas de mensajes procesos que comparten un mismo sistema de ficheros Tamaño del mensaje variable Flujo de datos bidireccional Sincronización: Envío asíncrono Recepción síncrona o asíncrona Los mensajes se pueden etiquetar con prioridades 79
80 Servicios UNIX para la gestión de colas de mensajes (I) Crear una cola de mensajes con nombre y atributos mqd_t mq_open(char *name, int flag, mode_t mode, struct mq_attr *attr) Los atributos se especifican en la estructura attr: mq_maxmsg mq_msgsize Número máximo de mensajes Tamaño del mensaje El segundo argumento es el modo de creación de la cola: O_NONBLOCK Envío y recepción no bloqueante Cerrar una cola de mensajes int mq_close(mqd_t mqdes) Borrar una cola de mensajes int mq_unlink(char *name) 80
81 Servicios UNIX para la gestión de colas de mensajes (II) Enviar un mensaje a una cola int mq_send(mqd_t mqdes, char *msg, size_t len, int prio) El mensaje msg de longitud len se envía a la cola de mensajes mqdes con prioridad prio Si la cola está llena el envío puede ser bloqueante o no (depende de O_NONBLOCK) Recibir un mensaje desde una cola int mq_receive(mqd_t mqdes, char *msg, size_t len, int prio) Recibe un mensaje msg de longitud len de la cola de mensajes mqdes con prioridad prio Recepción bloqueante o no (depende de O_NONBLOCK) 81
82 Productor-consumidor con paso de mensajes Productor () { } for(;;) { <Producir dato> send(consumidor, dato); } /* end for */ Consumidor () { } for(;;) { receive(productor, dato); <Consumir dato> } /* end for */ 82
83 Ejemplo VIII: Productor-consumidor con colas de mensajes #include <mqueue.h> #include <stdio.h> #define MAX_BUFFER 1024 /* tamaño del buffer */ #define DATOS_A_PRODUCIR /* datos a producir */ mqd_t almacen; void main(void){ } 83 /* cola de mensajes donde dejar los datos producidos y extraer los datos a consumir */ struct mq_attr attr; attr.mq_maxmsg = MAX_BUFFER; attr.mq_msgsize = sizeof (int); almacen = mq_open( ALMACEN, O_CREAT O_WRONLY, 0700, &attr); if (almacen == -1){ } Productor(); perror ( mq_open ); exit(-1); mq_close(almacen); exit(0);
84 Ejemplo VIII: Productor-consumidor con colas de mensajes Productor(void){ int dato; int i; for(i=0;i<datos_a_producir;i++){ /* producir dato */ dato = i; if (mq_send(almacen, &dato, siezof(int), 0)== -1){ perror( mq_send ); mq_close(almacen); exit(1); } } /* end for */ return; } /* end productor */ 84
85 Ejemplo VIII: Productor-consumidor con colas de mensajes #include <mqueue.h> #include <stdio.h> #define MAX_BUFFER 1024 /* tamaño del buffer */ #define DATOS_A_PRODUCIR /* datos a producir */ mqd_t almacen; void main(void){ /* cola de mensajes donde dejar los datos producidos y extraer los datos a consumir */ struct mq_attr attr; almacen = mq_open( ALMACEN, O_RDONLY); if (almacen == -1){ } Consumidor(); perror ( mq_open ); exit(-1); mq_close(almacen); } exit(0); 85
86 Ejemplo VIII: Productor-consumidor con colas de mensajes Consumidor(void){ int dato; int i; for(i=0;i<datos_a_producir;i++){ /* recibir dato */ dato = i; if (mq_receive(almacen, &dato, siezof(int), 0)== -1){ perror( mq_send ); mq_close(almacen); exit(1); } /* Consumir el dato */ printf( El dato consumido es: %d\n, dato); } /* end for */ return; } /* end consumidor */ 86
87 Comunicación de grupos Utiliza mensajes multicast Útil para: Ofrecer tolerancia a fallos basado en servicios replicados Localizar objetos en sistemas distribuidos Mejor rendimiento mediante datos replicados Actualizaciones múltiples Operaciones colectivas en cálculo paralelo emisor receptor IPC uno-a-uno IPC grupo o multidifusión 87
88 Tema 2 Comunicación y sincronización entre procesos Grupo ARCOS Grado en Ingeniería Informática Universidad Carlos III de Madrid
SISTEMAS OPERATIVOS:
SISTEMAS OPERATIVOS: Lección 7: Hilos y mecanismos de comunicación y sincronización Jesús Carretero Pérez Alejandro Calderón Mateos José Daniel García Sánchez Francisco Javier García Blas José Manuel Pérez
Más detallesSISTEMAS OPERATIVOS: COMUNICACIÓN Y SINCRONIZACIÓN ENTRE PROCESOS. Hilos y mecanismos de comunicación y sincronización
SISTEMAS OPERATIVOS: COMUNICACIÓN Y SINCRONIZACIÓN ENTRE PROCESOS Hilos y mecanismos de comunicación y sincronización Contenido 2 Comunicación y sincronización. Semáforos. El problema de los lectores escritores.
Más detallesSistemas operativos: una visión aplicada. Capítulo 5 Comunicación y sincronización de procesos
Sistemas operativos: una visión aplicada Capítulo 5 Comunicación y sincronización de procesos Sistema multiprogramado con un una CPU Proceso A Proceso B Proceso C Tiempo Sistemas operativos: una visión
Más detallesSistemas operativos: una visión aplicada. Capítulo 5 Comunicación y sincronización de procesos
Sistemas operativos: una visión aplicada Capítulo 5 Comunicación y sincronización de procesos Contenido Procesos concurrentes. Problemas clásicos de comunicación y sincronización. Mecanismos de comunicación
Más detallesProcesos ligeros. Arquitectura de Computadores II Universidad Carlos III de Madrid
Procesos ligeros Arquitectura de Computadores II Introducción Programa Archivo ejecutable residente en un dispositivo de almacenamiento permanente Se ejecuta por medio de la llamada exec() Proceso Es un
Más detallesSISTEMAS OPERATIVOS: PROCESOS. Hilos y Procesos
SISTEMAS OPERATIVOS: PROCESOS Hilos y Procesos ADVERTENCIA 2 Este material es un simple guión de la clase: no son los apuntes de la asignatura. El conocimiento exclusivo de este material no garantiza que
Más detallesProgramación Concurrente
Master en Computación Programación Concurrente Bloque II: Programación concurrente en POSIX Tema 1. Introducción al estándar POSIX Tema 2. Sistema Operativo MaRTE OS Tema 4. Gestión del Tiempo Tema 5.
Más detallesComunicación y Sincronizacion de procesos. Ingeniería del Software EUITI UPM. Seccion critica Productor consumidor Lectores escritores
Comunicación y Sincronizacion de procesos Ingeniería del Software EUITI UPM Índice Intro Seccion critica Productor consumidor Lectores escritores Tuberias Semaforos Memoria compartida Mutex y variables
Más detallesSincronización de Threads
Funciones POSIX III Funciones POSIX III Sincronización Sincronización Procesos Procesos Semáforos Semáforos (sem_t) (sem_t) Sincronización Sincronización Threads Threads Mutex Mutex (pthread_mutex_t) (pthread_mutex_t)
Más detallesAnalista Universitario en Sistemas. Sistemas Operativos. Instituto Politécnico Superior THREADS
THREADS 1 Introducción Los procesadores actuales permiten realizar muchas tareas en simultáneo En los sistemas la ejecución de las tareas puede intercalarse en un sólo procesador, y en casos de multi-procesadores,
Más detallesComunicación y Sincronizacion de procesos. Ingeniería del Software EUITI UPM
Comunicación y Sincronizacion de procesos Ingeniería del Software EUITI UPM Índice! Intro Seccion critica Productor consumidor Lectores escritores! Tuberias! Semaforos! Memoria compartida! Mutex y variables
Más detallesSISTEMAS OPERATIVOS: COMUNICACIÓN Y SINCRONIZACIÓN ENTRE PROCESOS. Desarrollo de servidores concurrentes
SISTEMAS OPERATIVOS: COMUNICACIÓN Y SINCRONIZACIÓN ENTRE PROCESOS Desarrollo de servidores concurrentes Contenido 2 Servidores de peticiones. Solución basada en procesos. Solución basada en hilos bajo
Más detallesInformática Electrónica Concurrencia
Informática Electrónica Concurrencia DSI- EIE FCEIA 2015 Que es concurrencia? Ejecución simultánea de dos o mas aplicaciones en una única plataforma de cómputo DSI EIE - FCEIA Informática Electrónica 2
Más detallesSISTEMAS OPERATIVOS: COMUNICACIÓN Y SINCRONIZACIÓN ENTRE PROCESOS. Procesos concurrentes y problemas en la comunicación y la sincronización
SISTEMAS OPERATIVOS: COMUNICACIÓN Y SINCRONIZACIÓN ENTRE PROCESOS Procesos concurrentes y problemas en la comunicación y la sincronización Contenido 2 Concurrencia. Condiciones de carrera. Exclusión mutua
Más detallesSistemas operativos. Comunicación y sincronización de procesos
Sistemas operativos Comunicación y sincronización de procesos Comunicación y sincronización de procesos Contenido 1. Introducción 2. Comunicación por memoria común 3. El problema de la sección crítica
Más detallesNº Mat. Calificación APELLIDOS NOMBRE. CURSO 4º GRUPO Julio 2014 ASIGNATURA: SISTEMAS INFORMÁTICOS INDUSTRIALES
APELLIDOS NOMBRE Nº Mat. UNIVERSIDAD POLITÉCNICA DE MADRID ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA Y DISEÑO INDSUTRIAL Departamento Electrónica, Automática e Informática Industrial 2. Problema de ADOO (10
Más detallesTema 4 El paradigma cliente-servidor
Tema 4 El paradigma cliente-servidor F. García-Carballeira, Mª. Soledad Escolar, Luis Miguel Sánchez, Fco. Javier García Sistemas Distribuidos Grado en Ingeniería Informática Universidad Carlos III de
Más detallesBiblioteca de sistema
* Para la realización del presente examen se aconseja un tiempo de 2 horas. Teoría 1. Explique en detalle cómo se pasa una llamada al sistema operativo. El sistema operativo se activa cuando debe responder
Más detallesSISTEMAS OPERATIVOS:
SISTEMAS OPERATIVOS: Lección 8: Desarrollo de servidores concurrentes Jesús Carretero Pérez Alejandro Calderón Mateos José Daniel García Sánchez Francisco Javier García Blas José Manuel Pérez Lobato Introducción
Más detallesSistemas operativos: una visión aplicada. Capítulo 3 Procesos
Sistemas operativos: una visión aplicada Capítulo 3 Procesos Contenido Procesos Multitarea Información del proceso Formación de un proceso Estados del proceso Procesos ligeros Planificación Señales y excepciones
Más detallesSincronización de procesos
Sincronización de procesos Contenido Procesos concurrentes. El problema de la seccion critica Problemas clásicos de comunicación y sincronización. Mecanismos de comunicación y sincronización. DSO 2014
Más detallesUnidad 1: Gestión de Procesos
Unidad 1: Gestión de Procesos Tema 1, Concurrencia: Exclusión mutua y sincronización. 1.1 Problema de la sección crítica, alternativas al uso de semáforos: - Regiones críticas, Monitores, Variables de
Más detallesSISTEMAS OPERATIVOS:
SISTEMAS OPERATIVOS: Lección 6: Procesos concurrentes y problemas en la comunicación y la sincronización Jesús Carretero Pérez Alejandro Calderón Mateos José Daniel García Sánchez Francisco Javier García
Más detallesFundamentos de los Sistemas Operativos
Práctica 3 : hilos! Fundamentos de los Sistemas Operativos Grado en Ingeniería Informática Rubén García Rodríguez Alexis Quesada Arencibia Eduardo Rodríguez Barrera Francisco J. Santana Pérez José Miguel
Más detallesSistemas Operativos: Programación de Sistemas. Curso Oscar Déniz Suárez Alexis Quesada Arencibia Francisco J.
Tema 5 : Comunicación entre Procesos mediante Tuberías Sistemas Operativos: Programación de Sistemas Oscar Déniz Suárez Alexis Quesada Arencibia Francisco J. Santana Pérez Curso 2006-07 Introducción Algunas
Más detallesHilos Secciones Stallings:
Capítulo 4 Hilos Secciones Stallings: 4.1 4.3 Contenido Procesos e hilos. Hilos a nivel de núcleo y a nivel de usuario. Multiprocesador simétrico (SMP). Micronúcleos. 1 Proceso Unidad de propiedad de los
Más detallesSISTEMAS OPERATIVOS Manejo de procesos
SISTEMAS OPERATIVOS Manejo de procesos Amilcar Meneses Viveros ameneses@computacion.cs.cinvestav.mx Universidad de Occidente Presentación Concepto de proceso Despacho de procesos Operaciones sobre procesos
Más detallesAcceso coordinado a recursos compartidos
Programación Concurrente en Linux Acceso coordinado a recursos compartidos Alberto Lafuente, Dep. KAT/ATC de la UPV/EHU, bajo Licencia Creative Commons 1 Contenido 1. Recursos compartidos 2. Mecanismos
Más detallesT5-multithreading. Indice
T5-multithreading 1.1 Indice Proceso vs. Flujos Librerías de flujos Comunicación mediante memoria compartida Condición de carrera Sección Crítica Acceso en exclusión mutua Problemas Abrazos mortales 1.2
Más detallesEstándares POSIX. Estándares base
Estándares POSIX Estándares base. ntaxis y semántica con diversos aspectos del sistema operativo No especifica la implementación La mayoría basados en el lenguaje C Interfaces en diferentes lenguajes Los
Más detallesSistemas operativos. Hasta ahora hemos visto. Relación programa-sistema operativo Gestión de memoria
Sistemas operativos UPCO ICAI Departamento de Electrónica y Automática 1 Hasta ahora hemos visto Relación programa-sistema operativo Gestión de memoria Reserva para la ejecución Pilas, heap, memoria de
Más detallesProgramación de Multitareas utilizando Hilos
Programación de Multitareas utilizando Hilos Enero/2012 Programación de Multitareas utilizando Hilos Origen de los hilos como elementos necesarios en la programación de multitareas Multihilos en un solo
Más detallesClases 04 y 05: Repaso de programación de sistemas basados en UNIX
Clases 04 y 05: Repaso de programación de sistemas basados en UNIX Prof. Edgardo Adrián Franco Martínez http://computacion.cs.cinvestav.mx/~efranco efranco.docencia@gmail.com Estructuras de datos (Prof.
Más detallesFunción monitoreo descriptor archivo #include <sys/types.h> #include<unistd.h> #include<errno.h> extern void procesamiento_datos(char *, int); void pr
Introducción al concepto de threads Dr.. Roberto Gómez Cárdenas DCC del ITESM-CEM rogomez@itesm.mx http://homepage.cem.itesm.mx/rogomez Función monitoreo descriptor archivo #include #include
Más detallesSistemas Operativos. Procesos
Sistemas Operativos Procesos Agenda Proceso. Definición de proceso. Contador de programa. Memoria de los procesos. Estados de los procesos. Transiciones entre los estados. Bloque descriptor de proceso
Más detallesCapítulo 2 Introducción a los sistemas operativos
Sistemas operativos: una visión aplicada Capítulo 2 Introducción a los sistemas operativos Contenido Qué es un sistema operativo? Arranque del computador Componentes y estructura de un sistema operativo
Más detallesInformática I Threads
Informática I Threads 28 de Setiembre 2010 1 Concepto de programación paralela. 2. 3 Concurrencia => Race Conditions. 4. 5 Funciones Concepto de Programación Paralela Computación paralela Técnica de programación
Más detallesPROCESAMIENTO DISTRIBUIDO
Pág. 1 INTRODUCCIÓN PROCESAMIENTO DISTRIBUIDO Arquitectura de comunicaciones: Software básico de una red de computadoras Brinda soporte para aplicaciones distribuidas Permite diferentes Sistemas Operativos
Más detalles26/01/2010. Espera activa Semáforos Problemas clásicos de com. y sin. Servicios POSIX
Tema 5: Comunicación y sincronización de procesos Tema 5: Comunicación y sincronización de procesos Comunicación y sincronización acó Espera activa Semáforos Problemas clásicos de com. y sin. Mecanismos
Más detallesBloque I: Principios de sistemas operativos
Bloque I: Principios de sistemas operativos Tema 1. Principios básicos de los sistemas operativos Tema 2. Concurrencia Tema 3. Ficheros Tema 4. Sincronización y programación dirigida por eventos Tema 5.
Más detallesProcesos y Threads Procesos y Threads. Concurrencia Concurrencia Ventajas Ventajas. Rendimiento Rendimiento (paralelismo) (paralelismo)
Procesos y Threads Procesos y Threads Procesos Procesos Threads Threads Concurrencia Concurrencia Ventajas Ventajas Modelos Modelos Información Información adicional () adicional () Preparado Preparado
Más detallesFundamentos de los Sistemas Operativos. Tema 2. Procesos José Miguel Santos Alexis Quesada Francisco Santana
Fundamentos de los Sistemas Operativos Tema 2. Procesos 1998-2015 José Miguel Santos Alexis Quesada Francisco Santana Contenidos del Tema 2 Qué es un proceso Estructuras de datos para gestionar procesos
Más detallesISO Tema 8,
ISO Tema 8, 2017-2018 Pablo González Nalda Depto. de Lenguajes y Sistemas Informáticos 13 de abril de 2018 Modificado el 27 de abril de 2018 de la presentación 1 2 3 4 5 6 7 2 / 32 1 2 3 4 5 6 7 3 / 32
Más detallesConcurrencia de Procesos
Concurrencia de Procesos Dos o mas procesos, se dice que son concurrentes o paralelos, cuando se ejecutan al mismo tiempo. Esta concurrencia puede darse en un sistema con un solo procesador (pseudo paralelismo)
Más detallesProgramación Concurrente
Master en Computación Programación Concurrente Bloque II: Programación concurrente en POSIX Tema 1. Introducción al estándar POSIX Tema 2. Sistema Operativo MaRTE OS Tema 3. Gestión de Threads Tema 4.
Más detallesPROGRAMACIÓN MULTITHREADING
ECAR 2012 PROGRAMACIÓN MULTITHREADING 1 PROGRAMACIÓN BÁSICA PROGRAMACIÓN MULTITHREADING Sergio Nesmachnow (sergion@fing.edu.uy) Gerardo Ares (gares@fing.edu.uy) Escuela de Computación de Alto Rendimiento
Más detallesTaller de Programación Paralela
Taller de Programación Paralela Departamento de Ingeniería Informática Universidad de Santiago de Chile April 26, 2007 Concurrencia 2 Concurrencia y sincronización.............................................................
Más detallesConcurrencia Monitores. Guillermo Román Díez
Concurrencia Monitores Guillermo Román Díez groman@fi.upm.es Universidad Politécnica de Madrid Curso 2016-2017 Guillermo Román, UPM CC: Monitores 1/25 Recursos Compartidos Pregunta La especificación de
Más detallesProcesos e hilos: cálculo de
Departamento de Automática 1 / 10 Índice Creación y sincronización de hilos Acceso a variables globales en exclusión mutua 2 / 10 Objetivo principal: obtener una aproximación al valor de empleando el método
Más detallesProgramación Concurrente Recopilación de teoría referente a la materia
UNIVERSIDAD AMERICANA Programación Concurrente Recopilación de teoría referente a la materia Ing. Luis Müller Esta es una recopilación de la teoría referente a la asignatura Programación Concurrente, a
Más detallesContenido 1. INTRODUCCIÓN A LOS SISTEMAS OPERATIVOS PROCESOS Prólogo...
1 Prólogo... xv 1. INTRODUCCIÓN A LOS SISTEMAS OPERATIVOS... 1 1.1. Conceptos generales sobre sistemas operativos... 2 1.1.1. Funciones del sistema operativo... 2 1.1.2. Componentes del sistema operativo...
Más detallesSincronización de Hilos POSIX
Sincronización de Hilos POSIX Sistemas Operativos (prácticas) E.U. Informática en Segovia Universidad de Valladolid Problemática Ejemplo: el problema del productor/consumidor (o del buffer acotado ) Existen
Más detallesThreads. Hilos - Lightweight process - Procesos ligeros
Threads Hilos - Lightweight process - Procesos ligeros 1 Temario Concepto y Beneficios Estructuras de implementación: Servidor- Trabajador, Equipo, Pipeline Reconocimiento: En el espacio del usuario /
Más detallesProgramación Concurrente y Paralela. Unidad 1 Introducción
Programación Concurrente y Paralela Unidad 1 Introducción Contenido 1.1 Concepto de Concurrencia 1.2 Exclusión Mutua y Sincronización 1.3 Corrección en Sistemas Concurrentes 1.4 Consideraciones sobre el
Más detallesPlataformas de Tiempo Real
Master en Computación Plataformas de Tiempo Real POSIX Avanzado y Extensiones Tema 1. Ficheros y entrada/salida Tema 3. Monitorización y control del tiempo de ejecución Tema 4. Planificación EDF Tema 5.
Más detallesSistemas Operativos 1
Ejercicio 1. Se desea implementar una aplicación de n procesos concurrentes, donde cada proceso ejecuta una determinada tarea en forma de pipeline. Un ejemplo de esta aplicación con n=4 sería la siguiente:
Más detallesComunicación y sincronización
Comunicación y sincronización Son conceptos relacionados con la interacción entre los procesos La comunicación se refiere al paso de información de un proceso a otro La sincronización corresponde al cumplimiento
Más detallesUNIVERSIDAD CARLOS III DE MADRID DEPARTAMENTO DE INFORMÁTICA INGENIERÍA EN INFORMÁTICA. ARQUITECTURA DE COMPUTADORES II 10 junio de 2006
UNIVERSIDAD CARLOS III DE MADRID DEPARTAMENTO DE INFORMÁTICA INGENIERÍA EN INFORMÁTICA. ARQUITECTURA DE COMPUTADORES II 10 junio de 2006 Para la realización del presente examen se dispondrá de 2 horas
Más detallesMC Hilda Castillo Zacatelco PROCESOS
MC Hilda Castillo Zacatelco hildacz@gmail.com PROCESOS Definición y atributos Un proceso es la instancia de un programa en ejecución. Desde el punto de vista del SO, un proceso es la entidad más pequeña
Más detallesPARTE II PROGRAMACION CON THREADS EN C
PARTE II PROGRAMACION CON THREADS EN C II.1 INTRODUCCION Una librería o paquete de threads permite escribir programas con varios puntos simultáneos de ejecución, sincronizados a través de memoria compartida.
Más detallesEjercicios sobre tuberías
Boletín 3. Ejercicios sobre tuberías July 14, 016 1. Indica de manera justificada si las siguientes afirmaciones sobre la utilización de tuberías como mecanismo de sincronización entre dos procesos son
Más detallesComunicación y sicronización de procesos
4 Comunicación y sicronización de procesos En este capítulo se presentan prácticas relacionadas con la comunicación y sincronización de procesos. El objetivo fundamental es que el alumno entienda el problema
Más detallesSi un candado mutex es usado por hilos en el mismo proceso pero no por hilos en diferentes procesos, los primeros dos pasos pueden simplificarse a:
Pthreads La biblioteca también soporta candados y variables de condición. Los candados pueden usarse para proteger la sección crítica, o pueden usarse en combinación con las variables de condición para
Más detallesCapítulo 5 Comunicación y sincronización de procesos
Sistemas operativos: una visión aplicada Capítulo 5 Comunicación y sincronización de procesos Contenido Procesos concurrentes. Problemas clásicos de comunicación y sincronización. Mecanismos de comunicación
Más detallesPROCESOS E HILOS - Hilo
1/6 PROCESOS E HILOS - Hilo! contexto de ejecución que se planifica de forma independiente pero que comparte un mismo espacio de direcciones con otros hilos - Proceso! conjunto de uno o más hilos y los
Más detallesTema 3. Paso de mensajes. mensajes. Bibliografía. Sistemas de paso de mensajes (2) Sistemas de paso de mensajes. Ventajas del paso de.
Tema 3. Paso de mensajes Bibliografía Programación Concurrente J. Palma, C. Garrido, F. Sánchez, A. Quesada, 2003 Capítulo 7 Principles of Concurrent and Distributed Programming M. Ben-Ari. Prentice Hall,
Más detallesSISTEMAS OPERATIVOS PROCESOS. Pedro de Miguel Anasagast
SISTEMAS OPERATIVOS PROCESOS Pedro de Miguel Anasagast ÍNDICE Conceptos generales de procesos Multitarea Servidores y demonios Servicios UNIX de gestión de procesos Señales y temporizadores Servicios UNIX
Más detallesBloque I: Principios de sistemas operativos
Bloque I: Principios de sistemas operativos Tema 1. Principios básicos de los sistemas operativos Tema 2. Concurrencia Tema 3. Ficheros Tema 4. Sincronización y programación dirigida por eventos Tema 5.
Más detallesComunicación entre Procesos
Sincronización y Comunicación de Procesos Sincronización y Comunicación de Procesos Sincronización Sincronización Comunicación Comunicación Condiciones de Condiciones de Carrera Carrera Memoria Memoria
Más detalles6. Enumere tres ventajas de los ULT frente a los KLT.
1 Tarea 3 Hilos 1. Cuales bloques de control de proceso deberían pertenecer a un bloque de control de hilo y cuáles a un bloque de control de proceso en un sistema multihilo? Para modelos monohilo deben
Más detallesTema 1: Programación Multiproceso. Curso
Tema 1: Programación Multiproceso. Curso 2012-2013 1 Patricia Hurtado Sayas Índice de contenidos: 1. Elementos funcionales de un SI. Repaso. 2. Concepto de Proceso o Tarea. 1. PCB, Bloque de Control de
Más detallesESCUELA DE INGENIERIA Informática Y Sistemas
ESCUELA DE INGENIERIA Informática Y Sistemas ASIGNATURA SISTEMAS OPERATIVOS CODIGO ST0257 SEMESTRE 2013-2 INTENSIDAD HORARIA 64 horas semestral CARACTERÍSTICAS Suficientable CRÉDITOS 4 1. JUSTIFICACIÓN
Más detallesFormatos para prácticas de laboratorio
CARRERA PLAN DE ESTUDIO CLAVE ASIGNATURA NOMBRE DE LA ASIGNATURA IC 2003-1 5314 Sistemas Operativos PRÁCTICA No. 6 LABORATORIO DE NOMBRE DE LA PRÁCTICA Comunicación entre procesos Tuberías DURACIÓN (HORA)
Más detallesProcesos Definición y Estados
Procesos Definición y Estados Profesorado de Informática CeRP del Suroeste, Uruguay Contenidos Qué es un proceso Estructuras de datos para gestionar procesos API para trabajar con procesos Hilos (threads).
Más detallesConcurrencia. Primitivas IPC con bloqueo
Concurrencia Primitivas IPC con bloqueo Primitivas de IPC con bloqueo La solución de Peterson es correcta, pero tiene el defecto de requerir espera ocupada: Cuando un proceso quiere entrar en su región
Más detallesConcurrencia en UNIX / LINUX. Introducción: Procesos e Hilos POSIX
Concurrencia en UNIX / LINUX Introducción: Procesos e Hilos POSIX El estándar POSIX POSIX: Interfaz de sistemas operativos portables. Basado en UNIX A pesar de que UNIX es ya de por sí estándar, había
Más detallesTEMA 3. CONCEPTOS FUNDAMENTALES DEL NIVEL DEL SISTEMA OPERATIVO. Definición y objetivos de un S.O
TEMA 3. CONCEPTOS FUNDAMENTALES DEL NIVEL DEL SISTEMA OPERATIVO Definición y objetivos de un S.O Definición y objetivos del sistema operativo Estructura, componentes y servicios de un S.O Llamadas al sistema
Más detallesSISTEMAS OPERATIVOS INTRODUCCIÓN. Pedro de Miguel Anasagast
SISTEMAS OPERATIVOS INTRODUCCIÓN Pedro de Miguel Anasagast INTRODUCCIÓN AL SISTEMA OPERATIVO MÁQUINA DESNUDA Máquina desnuda: Término que se aplica a un computador carente de sistema operativo. El término
Más detallesEntorno de programación de nivel 1: La librería PCAP
Entorno de programación de nivel 1: La librería PCAP La librería libpcap nos permite capturar paquetes desde un programa C. En sistemas Windows, la librería se llama Winpcap. Para compilar cualquier programa
Más detallesPlataformas de Tiempo Real
Master en Computación Plataformas de Tiempo Real POSIX Avanzado y Extensiones Tema 1. Ficheros y entrada/salida Tema 2. Gestión de Interrupciones en MaRTE OS Tema 3. Monitorización y control avanzado del
Más detalles*** SOLUCIONES *** SISTEMAS OPERATIVOS Examen Parcial 24 de Abril de 2010
Calificación SISTEMAS OPERATIVOS Examen Parcial 24 de Abril de 2010 1 2 3 4 Nombre *** SOLUCIONES *** Titulación Dispone de tres horas para realizar el examen 1 (5 puntos) Test. En cada uno de los siguientes
Más detallesHilos de ejecución POSIX
Hilos de ejecución POSIX Ampliación de Sistemas Operativos (prácticas) E.U. Informática en Segovia Universidad de Valladolid Hilos de ejecución Concepto Un proceso convencional se caracteriza por: Ser
Más detallesTaller de Programación Paralela
Taller de Programación Paralela Departamento de Ingeniería Informática Universidad de Santiago de Chile April 4, 2008 y sincronización Cuando dos o más tareas (procesos o hebras) comparten algún recurso
Más detallesSistemas Operativos sesión 12: tuberías
Sistemas Operativos sesión : tuberías Grado en Ingeniería Informática Universidad Carlos III de Madrid Agenda Linux Comunicación con tuberías Ejercicios Agenda Linux Comunicación con tuberías Ejercicios
Más detallesFunciones POSIX III Funciones POSIX III. No Nombrados Nombrados. sem_open sem_open. sem_close sem_close. sem_unlink sem_unlink
Funciones POSIX III Funciones POSIX III Sincronización Sincronización Procesos Procesos Semáforos Semáforos (sem_t) (sem_t) Sincronización Sincronización Threads Threads Mutex Mutex (pthread_mutex_t) (pthread_mutex_t)
Más detallesConcurrencia, exclusión mutua y sincronización. Capítulo 5 HungriaBerbesi
Concurrencia, exclusión mutua y sincronización Capítulo 5 HungriaBerbesi 1 Concurrencia Múltiples aplicaciones Aplicaciones estructuradas Estructura del sistema operativo 2 Concurrencia 3 Sección Crítica:
Más detallesSistemas operativos: una visión aplicada. Capítulo 3 Procesos. Contenido
Sistemas operativos: una visión aplicada Capítulo 3 Procesos Contenido Procesos Multitarea Información del proceso Formación de un proceso Estados del proceso Procesos ligeros Planificación Señales y excepciones
Más detallesTaller de pthreads. Sistemas Operativos. Verano de 2009
Verano de 2009 Menú del día Hoy veremos: Introducción a pthreads Creación de threads Variables mutex Variables de condición Tutoriales de HPC Lawrence Livermore National Laboratory (http://www.llnl.gov)
Más detallesdit Programación concurrente Sincronización condicional UPM
20151028 dit UPM Programación concurrente Sincronización condicional Juan Antonio de la Puente Algunos derechos reservados. Este documento se distribuye bajo licencia Crea9ve Commons
Más detallesPrácticas de Sistemas operativos
Prácticas de Sistemas operativos David Arroyo Guardeño Escuela Politécnica Superior de la Universidad Autónoma de Madrid Segunda Semana: Procesos, Procesos Padre y Procesos Hijo, familia exec() 1 Entregas
Más detallesde Gran Canaria Centro de Tecnología Médica Programación Concurrente
Universidad de Las Palmas de Gran Canaria Centro de Tecnología Médica http://www.ctm.ulpgc.es Tema 1: Introducción a la Escuela Técnica Superior de Ingenieros de Telecomunicación Conceptos Fundamentales
Más detallesTema 4: Gestión de Procesos
Tema 4: Gestión de Procesos SSOO - Curso 2005/06 E. Domínguez C. Villarrubia Departamento de Tecnologías y Sistemas de Información Escuela Superior de Informática Universidad de Castilla - La Mancha Marzo
Más detallesFunciones POSIX (I): Introducción
Funciones POSIX I Funciones POSIX I Llamadas al Llamadas al Sistema Sistema Gestión Básica Gestión Básica de Procesos de Procesos Procesos Procesos fork fork Señales Señales getpid getpid Memoria Memoria
Más detallesProcesos. Procesos. Sistemas Operativos Procesos KMC 2017
Procesos Procesos Concepto de Proceso Planificación de Proceso Operaciones sobre Procesos Comunicaciones Interprocesos (IPC) Ejemplos de Sistemas de IPC Comunicación en un Sistema Cliente-Servidor 1 Concepto
Más detallesMessage Passing Interface (MPI)
Message Passing Interface (MPI) INTRODUCCIÓN MPI (Message Passing Interface) como es un interfaz estandarizada para la realización de aplicaciones paralelas basadas en pasaje de mensajes. El modelo de
Más detallesInterbloqueo. Concurrencia: Interbloqueo e Inanición
Interbloqueo Concurrencia: Interbloqueo e Inanición Capítulo 6 Bloqueo permanente de un conjunto de procesos que compiten por recursos del sistema o por comunicación con los otros No existe una solución
Más detallesUniversisdad de Los Andes Facultad de Ingeniería Escuela de Sistemas
Universisdad de Los Andes Facultad de Ingeniería Escuela de Sistemas Introducción y Conceptos Básicos Prof. Gilberto Díaz gilberto@ula.ve Departamento de Computación, Escuela de Sistemas, Facultad de Ingeniería
Más detallesGuillermo Román Díez
Concurrencia Creación de Procesos en Java Guillermo Román Díez groman@fi.upm.es Universidad Politécnica de Madrid Curso 2016-2017 Guillermo Román, UPM CC: Creación de Procesos en Java 1/18 Concurrencia
Más detalles