Procesos e hilos - elai.upm.es · La unidad de procesamiento gestionada por el S.O. Presencia en...

Procesos e hilosPablo San Segundo (C-206)

[email protected]

KERNEL DEL SISTEMA OPERATIVO

Al arrancar el PC siempre se carga en memoria una copia del Kernel desde disco

El Kernel del sistema operativo es un programa,

típicamente programado en C

¿Qué es un Proceso?

Un programa en ejecuciónLa unidad de procesamiento gestionada por el S.O.

Presencia en memoria y tabla BCP

Registros de la CPUContexto

EntornoIdentificadores de usuario y grupoIdentificador de procesoVariables de entorno

UsuarioSistema

Control (tablas)Estado: Bloqueado, ejecución, listoPrioridad: cola de prioridadesE/S: Desc. recursos, ,mensajería etc.Presencia en memoria

typedef struct bcp {

struct bcp *siguiente; struct bcp *anterior; struct bcp *hebraint retardo; palabra marco; palabra pila; palabra marcador; int pri; int estado; struct bcp *todosenl; int mascara; k_ptrmens retenmensprocnombre nombre;

} bcp;

Bloque de Control de Proceso

ESTADOS BÁSICOS DE UN PROCESO

EN EJECUCIÓNUn proceso por procesador

BLOQUEADOEn espera de completar E/S

LISTOPreparado para pasar al estado de ejecución

ENTORNO DEL PROCESO

DefiniciónTabla NOMBRE-VALOR que se pasa al proceso en su creación

UbicaciónImagen en Memoria: típicamente en la pila

ValorPor defectoMandatos Shell (API S.O.)

PATH=/usr/bin:/home/pss/bin

TERM=tty100

HOME=/home/pss

PDW=/home/pss/ingsw

SHELL

echo $PATHecho $HOME

SHELL

PATH=$PATH:XXX

CARACTERÍSTICAS DE PROCESOS

Jerarquías (familias)Procesos hijo, padre, hermano, abuelo etc..

VidaCreaciónEjecuciónMuerte

Tipo de ejecuciónBatch (lotes)Interactivo

INI

INI SES INI SES

SHELL SHELL

PROC 1 PROC 2

USUARIO

DefiniciónPersona autorizada a utilizar el sistema

AutenticaciónUser login (internamente es un número para el S.O.: i.e uid)Contraseña (password)

Super-usuario (sudo, su)

Derechos de administrador

Grupo de usuariosColectivo de usuarios con los mismos permisosTodo usuario ha de pertenecer a un grupo

FIN DE INTRODUCCIÓN

Clasificación de los Sistemas Operativos

Fundamento del multiproceso

DefiniciónEjecución concurrente real de varios procesos con un solo procesador

BasesAlternancia de los procesos en la CPU durante la fase de E/SAlmacenamiento en memoria de varios procesos simultáneamente

Ejemplo

Ejecución de proceso nulo

VENTAJAS DE LA MULTITAREA

Funcionamiento del SO en modo ‘interactivo’ de forma eficiente

Aprovecha tiempos de espera de procesos durante E/SAumenta el uso de la CPU

Nuevo paradigma de programaciónPrincipio de ‘modularidad’: Un programa-varios

‘procesos’

GRADO DE MULTIPROGRAMACIÓN

DefiniciónNúmero de procesos activos en un instante de tiempo

RecursoMemoria principal

Sistema SIN memoria virtual


Sistema CON memoria virtual


Sistema CON memoria virtual

RENDIMIENTO DEL PROCESADOR

HIPER-PAGINACIÓN

FIN DE S.O. MULTITAREA

INFORMACIÓN DEL PROCESO EN S.O.i.e. RIED

Se gestionan fuera del BCP. ¿Por qué?

CODIGO

PILA

DATOS

ESTADO DEL PROCESO : CONTEXTORegistros generales

Motorola 68000: A0-A7, D0-D7Contador de programa (PC)

Siguiente instrucción a ejecutarPuntero de Pila (“Call Stack pointer”)

Referencia la pila en memoria asociado a todo procesoMotorola 68000 (USP y SSP)

Puntero de marco (“Frame pointer”)Registro de Estado

Modo de ejecución, máscaras de interrupciones, información acerca de la última operación realizada en la ALU, etc…Motorola 68000 (SR)

Registros especialesEjemplo: RIED: Registro que Identifica el Espacio de Direcciones que ocupa en memoria el proceso en ejecución

PROCESO EN MEMORIA

Pertenece al BCP

Preasignación inicial de zona de swapping

Segmentación fija Hoy en día la segmentación es variable

TABLAS DEL SISTEMA OPERATIVO

Tabla de procesos (BCP)Información exclusiva de cada proceso que no se puede COMPARTIR y cuyo tamaño no varía durante la ejecución de cada proceso (IMPLEMENTACIÓN)

Tabla de Memoria (alias paginado)Información para la gestión de memoria

Tabla de Entrada / SalidaInformación relativa a periféricos y a las operaciones E/S

Tabla de FicherosInformación sobre los ficheros utilizados por los procesos

Ejemplo Tabla de Ficheros

COMPARTEN LECTURA Y ESCRITURA EN FICHERO

Puntero de posición

TABLA DE FICHEROS

Doble direccionamiento

EJEMPLO: INFORMACIÓN EN EL BCP

TREEPS (LINUX)

FIN DE PRESENCIA EN MEMORIA DE

UN PROCESO

NACIMIENTO DE UN PROCESO

Linker

A imagen en memoria

Transmisión de ficheros al Motorola 68000

e.g. kernel.lib/dll

FORMACIÓN DE UN PROCESO

EL EJECUTABLE NO CONTIENE A LAS BIBLIOTECAS DEL SISTEMA

COPIA DE LAS BIBLIOTECAS DEL SISTEMA EN LA IMAGEN DE MEMORIA

(kernel.lib)

Tablas S.O.

SE ACTUALIZA LA PRIMERA VEZ Y EN CADA CAMBIO DE CONTEXTO

FIN DE FORMACIÓN DE UN PROCESO

SERVICIOS DE GESTIÓN DE PROCESOS

Identificación de procesosEntorno de un procesoCreación de procesosCambio de imagen de un procesoEspera a la terminación de un procesoFinalización de la ejecución de un procesoInformación adicional

SERVICIO POSIX: fork

Definiciónpid_t fork (void) : Crea un proceso hijo clonando al padre.

Copia no exacta (i.e. señales)

Librerías#include <sys/types.h>

RetornoIdentificador de proceso padre0 hijo-1 si error

DescripciónCrea un proceso hijo que ejecuta el mismo programa que el padreSe heredan los descriptores (i.e. archivos)Se desactivan las alarmas pendientes

SERVICIO POSIX: fork

Depende de la distribución

SERVICIO POSIX: exec

DefiniciónCambia el programa del proceso

Los descriptores abiertos se mantienen

EJEMPLO: Servicio fork

int main() { pid_t pid;pid=fork();if (pid= = -1)

cout<<“Error”<<endl;else if (pid == 0) {

cout<<“Proceso hijo”<<endl;} else{

cout<<“Proceso padre”<<endl;}

return 0;}

#include <sys/types.h>#include <iostream>

SERVICIO POSIX: exec

Declaracionesint execl (const char* path, const char* arg,…)int execlp(const char* file, const char* arg,…)int execvp(const char* file, const char* arg[])

Retorno-1 si error o NO RETORNA

DescripciónEl mismo proceso ejecuta otro programaLos descriptores abiertos permanecen abiertosLas señales toman la acción por defecto

Ultimo parámetro NULL

#include <unistd.h>

EJEMPLO: Servicio execl

int main() { pid_t pid;if ((pid = fork()) = = -1)


if(execl ("/bin/ls, “ls", “-l”, NULL)){ cout<<“Error al lanzar la tarea”<<endl;

}}int status;wait(&satus);

return 0;}

#include <sys/types.h>#include <unistd.h>#include <iostream>

EJEMPLO: Servicio execv

int main() { pid_t pid;char * arg[3];arg[0]=“gedit”; arg[1]=“test.cpp”;arg[2]=NULL;if ((pid = fork()) = = -1)


if(execvp (arg[0], arg)){ cout<<“Error al lanzar la tarea”<<endl;

}}int status;wait(&satus);

return 0;}

#include <sys/types.h>#include <unistd.h>#include <iostream>

SERVICIO POSIX: int exit (int status)Definición

Termina un proceso, devolviendo el parámetro status al proceso padre

Declaraciónvoid exit (int status)

EXIT_SUCCESS, EXIT_FAILUREArgumento

Código de retorno al proceso padreDescripción

Finaliza la ejecución del procesoCierra todos los descriptoresSe liberan todos los recursos

#include <stdlib.h>

SERVICIO POSIX: waitDefinición

Espera la terminación de un proceso hijo CUALQUIERADeclaración

pid_t wait (int* status)pid_t waitpid (int pid, int* status, int options)

RetornoIdentificador del proceso hijo, -1 si error

DescripciónPermite a un proceso padre esperar hasta que termine un proceso hijoDevuelve el estado del proceso hijo al terminar

Macros para analizar el estado: WIFEXITED, WEXITSTATUSWIFSIGNALED, WTERMSIG, etc…

WUNTRACEDWNOHANG

#include <sys/wait.h>

EJEMPLO : Servicio wait con MACROSint main(){

int status;pid_t pid;pid= fork();if(pid==0){

execlp(“gedit”, “main.cpp”, NULL);exit(EXIT_SUCCESS);

}wait(&status) ;if(WIFEXITED(status)){

if(WEXITSATUS(status)==EXIT_SUCCESS){cout<<“OK”<<endl;

}else if(WEXITSATUS(status)==EXIT_FAILURE)){cout<<“ERROR”<<endl;

}}cout<<"Proceso padre terminado"<<endl;

exit(EXIT_SUCCESS);}

Capturar el error

EJEMPLO : Servicio wait multiproceso

int main(){

int status;pid_t pid;for(int i=0; i<10; i++){

pid= fork();if(pid==0){

cout<<"hilo: "<<i<<endl;exit(EXIT_SUCCESS);

}}

//Espera a todos los hijoswhile ( wait(&status) !=-1 ){;}cout<<"Proceso padre terminado"<<endl;


EJEMPLO: waitpidint main(void){

int status;pid_t pid;pid= fork();if(pid==0){

sleep(5);cout<<"proceso hijo terminado"<<endl;exit (EXIT_SUCCESS);

}

pid_t endid= waitpid(pid,&status, WNOHANG); //no bloqueanteif(endid==pid){

cout<<"status del hijo diposnible"<<endl;} else{

cout<<"padre termina sin conocer el status del hjo"<<endl;}

exit (EXIT_SUCCESS);}

Caso de uso típico de exec /fork /wait

Padre e hijo comparten recursos

EVOLUCIÓN DE PROCESOS: ZOMBIES

El hijo muere antes de la ejecución de un servicio wait(…) del padre

Hijo: Proceso ZOMBIE

BCP de B sigue existiendo

EJEMPLO: Zombies

int main(void){

pid_t pid;pid= fork();switch(pid){

case -1:cout<<"Error al creado proceso duplicado"<<endl;exit(EXIT_FAILURE);

break;case 0:sleep(1);cout<<"proceso hijo terminado"<<endl;exit(EXIT_SUCCESS);

break;}

cout<<“hijo terminará sin wait del padre: ¡ZOMBIE!"<<endl;sleep(30);int status;wait(&status);

exit(EXIT_SUCESS);}

EJEMPLO: JERARQUÍAS DE PROCESOS

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

int i, valor;pid_t pid_1, pid_2;

i=atoi(argv[1]);pid_1=fork();

while(i>0){pid_2=fork();if(pid_2!=0) {

wait(&valor)break;

}i=i-1;

}return 0;}

#include <sys/types.h>

<Nombre Ejecutable> 3

Ejecución desde Terminal

¿JERARQUÍA DE PROCESOS ?

A) Figura

B) Sin Bloque


Ejercicio: Procesos distribuidos (I)

Impleméntese un proceso que lance latarea de leer un grafo en formato DIMACSde un fichero de texto y devuelva su gradoen pantalla.

El proceso principal debe esperar a laterminación de dicha tarea e indicar si seha resuelto correctamente.

FIN DE SERVICIOS POSIX PARA PROCESOS

ESTADOS DE UN PROCESO

SWAPPING

PlanificadorCorto Plazo

PLANIFICACIÓN DE PROCESOS

Planificador (Planner): Programa del S.O. que determina que proceso tiene que ejecutarse.Activador (Dispatcher) : Programa del SO que carga el programa seleccionado por el planificador en memoria

Formas de planificar del S.O:Largo plazo: Decidir que procesos batch entran a ejecutarseMedio plazo: Añadir procesos a RAM

Finalización del estado de suspendido.Sistemas con swapping.

CORTO PLAZO: DECIDIR QUÉ PROCESO TOMA EL CONTROL DE LA CPU

NOCIONES BÁSICAS DEL CORTO PLAZO

Tipos de planificaciónSin expulsión: El proceso conserva la CPU mientras lo deseeCon expulsión: El S.O. quita la CPU al proceso cada cierto tiempo.

Colas de procesosPor prioridad (niveles)Por tipo

LotesInteractivo

Reparto de la CPU equitativoEficiencia (optimizar uso CPU)Mejorar el tiempo de respuesta

Modo interactivoModo lotes

Cumplir plazos de ejecución en sistemas de tiempo real

OBJETIVOS DE LA PLANIFICACIÓN

INCOMPATIBILIDAD DE OBJETIVOS!

Windows NT Server ≠ Windows 7 Home Edition

COLAS DE PROCESOS

EJEMPLO

BATCH

Implementación de colas de procesos

Implementación con punteros a otros BCPAcceso eficiente

COLAS DE PRIORIDAD

ALGORITMOS DE PLANIFICACIÓNCÍCLICA (Round Robin)

Asignación de CPU rotatoriaSe asigna un tiempo máximo a todos los procesos (time slot )Los procesos se organizan en una cola circular

Un proceso que excede su slot se expulsa y se coloca al final de la cola

SISTEMAS DE TIEMPO COMPARTIDOREPARTO por UID en vez

de por TIEMPO de PROCESAMIENTO

ALGORITMOS DE PLANIFICACIÓN (II)

FIFO (‘first in-first out’)Los procesos se organizan según una cola ‘clásica’. Entran por el final y esperan su turno.Política de planificación SIN EXPULSIÓNEl proceso en ejecución sólo será expulsado cuando él mismo realiza una llamada bloqueante al sistema (i.e. E/S)Problema: INANICIÓN

Se suele combinar con política de prioridades (i.e. POSIX)

PROCESAMIENTO POR LOTES

ALGORITMOS DE PLANIFICACIÓN (III)

PrioridadesFijas: Problema de inanición (p. ej. RTOS)Variables (aumentan con envejecimiento)

El trabajo más corto primeroAplicación en sistemas BatchMenor tiempo de respuestaPenaliza las tareas largasDificultad en conocer ‘a priori’ las tareas de mayor duración.

Aleatorio

ALGORITMOS DE PLANIFICACIÓN RT (IV)

Definición Sistemas de Tiempo Real (RTOS)Sistemas donde los procesos deben ejecutarse en instantes predeterminados

Tipos de RTSRequisitos blandos / durosEjecución a plazo fijo / periódico

2h:30m:10s

2h:30m:10s 2h:30m:20s

PrioridadReloj de tiempo

9-2-2006 / 2h:30m:15s

La CAPACIDAD DE PROCESAMIENTO NO es especialmente altaPREPROCESAMIENTO PREDECIBLE: Sin caches, sin

paginación, sin predicción de saltos

REQUISITOS DUROS: En ningún caso de puede rebasar el tiempo de reloj asociado al proceso

EJEMPLOS

QNX

RTLinux

VxWorks

Windows CE

PLANIFICACIÓN EN POSIX

PrioridadAbsoluta (RT)

(0)-normal | (>0)-RTDinámica

POSIX 19 a -20 (mayor número menor prioridad)

El planificador siempre elige aquellos procesos con mayor prioridad

Políticas de planificaciónFIFO (procesamiento por lotes)Cíclica (modo interactivo)Otra

Ejercicio: Procesos distribuidos (I)Algunos servicios POSIX para prioridad dinámica

int setpriotiy (PRIO_PROCESS, int pid, int niceval) RETURN VALUE: -1 ERROR, 0 OK

int getpriority (PRIO_PROCESS, int pid)

Escriba un programa en C para POSIXque lance dos tareas P1 y P2 quecompartan escritura en un fichero de texto“log.txt”.

Modifique la prioridad de P1 y P2 ycompruebe como afecta a la salida.


Soluciónint main(void){

pid_t pid, pid2;ofstream f("log.txt", ios::app); //fichero compartidopid=fork();if(pid==0){

sleep(1);cout<<"Proc 1: "<<getpriority(PRIO_PROCESS,pid)<<endl;//…escribir en ficheroexit(EXIT_SUCCESS);

}pid2=fork();if(pid2==0){

sleep(1);cout<<"Proc 2: "<<getpriority(PRIO_PROCESS,pid)<<endl; //…escribir en ficheroexit(EXIT_SUCCESS);

}setpriority(PRIO_PROCESS,pid,19);setpriority(PRIO_PROCESS,pid2,0);int status;while(wait(&status)!=-1) continue;f.close();

execlp("gedit", "gedit", "log.txt", NULL); //opcionalexit (EXIT_SUCCESS);}

PLANIFICACIÓN WINDOWS NT

FIN DE POLÍTICAS DE PLANIFICACIÓN

THREAD (Proceso ligero)

DefiniciónUn thread es un proceso que comparte un espacio en memoria con otros threads.

Estructura de un proceso en WIN NT

COMPARTEN MEMORIA

¡Si termina el hilo principal mueren el resto de hilos!

Paralelización con procesos ligeros

PROGRAMACIÓN CON THREADSUn thread es equiparable a una función que se ejecuta en PARALELO con otras funciones (threads)

Programación con hilosElevada dificultadAl escribir código es fundamental tener en cuenta un PARALELISMO REAL (aun cuando se tenga un solo procesador)Imaginar LLAMADAS DISTINTAS AL MISMO CÓDIGO

Comunicación entre hilos Variables compartidas en memoriaDescriptores de recursos compartidos,Elementos de sincronización compartidos etc.

Aumenta la velocidad de ejecución de tareas con E/S

APLICACIÓN: DISEÑO DE SERVIDORES

Tres arquitecturas de servidor

GESTIÓN DE PROCESOS LIGEROS

JOINING es uno de los mecanismos de sincronización de hilos

SERVICIOS POSIX PARA PROCESOS LIGEROS (I)

int pthread_create (pthread_t* , const pthread_attr_t*, void* (*func)(void*), void* arg )

Crea un proceso ligero que ejecuta func con argumentos arg y atributos attrAtributos (modificables mediante servicios)

Tamaño de la pilaPrioridad, Política de planificación etc.

RETURN VALUE: 0-OK o ERRNUM

void pthread_exit (void* value)Finaliza la ejecución e indica el estado de terminación

pthread_t pthread_self (void)Devuelve el identificador del thread que realiza la llamada

¿COMPARATIVA CON EXIT PARA PROCESOS?

SERVICIOS POSIX PARA PROCESOS LIGEROS (II)

int pthread_join (pthread_t tid, void ** value_ptr)Suspende la ejecución de un thread JOINABLE hasta que termina el thread (a no ser que haya terminado)Devuelve el estado de terminación del thread en value_ptrsegún devuelto por pthread_exit o PTHREAD_CANCELED .RETURN VALUE: 0-OK

int pthread_detach (pthread_t pid)Convierte un hilo en DETACHED en tiempo de ejecuciónRETURN VALUE: 0-OK

#include <pthread.h> Linkar con pthread

Ejemplos: Hilos-Creación

int main(void){

pthread_t thid;pthread_create(&thid, NULL, sumar_thread, NULL);

if(pthread_join(thid,NULL)){ //0-OKcout<<“Hilo joinable no terminado adecuadamente”<<endl;

}exit(EXIT_SUCCESS);}

void* sumar_thread (void*){

int a=5;int b=8;cout<<“la suma del hilo es:”<<a+b<<endl;

phtread_exit(NULL);}

Ejemplos: Hilos-Paso de parámetros

struct sSUMANDOS {int a; int b;} ;int main(void){

sSUMANDOS sum; sum.a=10; sum.b=20;pthread_t thid;pthread_create(&thid, NULL, sumar_thread, &sum);

pthread_join(thid,NULL);exit(EXIT_SUCCESS);}

void* sumar_thread (void*param){

sSUMANDOS* p=(sSUMANDOS*) param;cout<<“la suma del hilo es:”<<p a +p b<<endl;


Ejemplos: Hilos-Comunicación (I)



pthread_join(thid,NULL);cout<<“Los valores nuevo son:”<<sum.a<“:”<<sum.b<<endl;



sSUMANDOS* p=(sSUMANDOS*) param;p a=8; p b=10; //…modifica variable en bloque invocante


Ejemplos: Hilos-Comunicación (II)



void* ret_thread;pthread_join (thid, &ret_thread);sSUMANDOS ret;ret.a=((sSUMANDOS*) ret_thread) a;ret.b=((sSUMANDOS*) ret_thread) b;cout<<“Los valores devueltos son:”<<ret.a<“:”<<ret.b<<endl;



sSUMANDOS* p=(sSUMANDOS*) param;sSUMANDOS* pret=new sSUMANDOS;pret->a=p a*2; pret->b=p b*2; //mod. de valores

phtread_exit(pret);}

Ejemplos: Hilos-Comunicación (III)

struct sSUMANDOS {int a; int b;} ;int suma=0; //variable compartida en memoriaint main(void){


pthread_join(NULL);cout<<“La suma es:”<<suma<<endl;



sSUMANDOS* p=(sSUMANDOS*) param;suma=p a + p b;


Ejemplos: Hilos-DETACHED

int main(void){

pthread_t thid;pthread_create(&thid, NULL, sumar_thread, NULL);

pthread_detach (thid);pthread_join(NULL);cout<<“hilo principal terminado”<<endl;



sleep(10);cout<<“hilo terminado”<<endl;


SERVICIOS POSIX PARA PROCESOS LIGEROS (III)

int pthread_attr_init (pthread_attr_t* attr)Inicializa la estructura de atributos de un thread a sus valorespor defecto previstos por el S.O.RETURN VALUE: 0-OK

int pthread_attr_setdetachstate (pthread_attr_t* attr, intdetachstate)

Establece la forma de terminar de un proceso ligeroSi detachstate = PTHREAD_CREATE_DETACHED el proceso ligero libera sus recursos cuando finalice su ejecuciónSi detachstate = PTHREAD_CREATE_JOINABLE no se liberan los recursos. Hay que utilizar pthread_join(…)En el caso general los hilos deberían ser generados como joinable (recomendado en el standard de POSIX)RETURN VALUE: 0-OK

Por defecto

SERVICIOS POSIX PARA PROCESOS LIGEROS (IV)

int pthread_attr_setschedpolicy(pthread_attr_t* attr, intschedpol)

Establece la política de planificación de un proceso ligeroTiene que tener la proiedad de PTHREAD_EXPLICIT_SCHEDSi schedpol = SCHED_FIFO: política FIFOSi schedpol = SCHED_RR : política ROUND ROBIN

int pthread_attr_setinheritsched (pthread_attr_t* attr, intinheritsched)

Establece la política de planificación en relación con el padreSi inheritsched = PTHREAD_EXPLICIT_SCHED se permite que tenga una política de planificación diferente a la del padreSi inheritsched = PTHREAD_INHERIT_SCHED se hereda la política de planificación del padre

Por defecto

Por defecto

EJEMPLO JERARQUÍA DE THREADS (I)

LIBRERÍA

THREAD

ATRIBUTOS

EJEMPLO THREADS (II)

ATRIBUTO DETACHED

ESPERA A TERMINACIÓN DE HIJOS

¿PASO DE PARÁMETROS?

FIN DE SERVICIOS POSIX PARA HILOS

Procesos e hilos - elai.upm.es · La unidad de procesamiento gestionada por el S.O. Presencia en...

Documents

Transcript of Procesos e hilos - elai.upm.es · La unidad de procesamiento gestionada por el S.O. Presencia en...