UAH _Universidad de Alcalá de Henares_ _ Grado en Ingeniería Informática _ Ejercicios Sistemas Operativos _ Ejercicios

Ingeniería de Software I

•
Outros

Materiales Generales
12/5/2022
Esta es una vista previa del archivo. Inicie sesión para ver el archivo original
Ejercicios Examen Años Pasados/4_32755387694317668.rar 
Sistemas Operativos/ssoo/tema 3 ssoo/ApuntesTema3.txt.Programa
- Un programa es un archivo con instrucciones que no se ejecutan en ese momento.
- El programa es una entidad estatica, se le asignan los recurso al programa en ejecucion.
.Desarrollo de un programa
- La "Depuracion" sirve para encontrar errores en tiempo de ejecucion.
	(Buscar en Wikipedia los depuradores y sus 4 fases)
.Fases de desarrollo
- Biblioteca: conjunto de archivos orientados a una funcion. (Funciones matematicas, etc.)
	(Bibliotecas estaticas las referencias se asignan en el enlazado.) Saber como concepto
	(Bibliotecas dinamicas se asignan en la carga o ejecucion.) Saber como concepto
- Hasta el momento de ejecucion de un programa se manejan direcciones simbolicas no fisicas.
.Fases de desarrollo en UNIX
- "gcc" para compilar (gcc programa.c -o programa para darle el nombre "programa")
- "gdb" para depurar
- $ gdb "nombre ejecutable" (Sin comillas)
- Pasos del gcc:
	1º cpp -> Preprocesamiento
	2º comp -> Compilacion y optimizacion
	3º as -> Generacion de codigo objeto
	4º ld -> Enlace
- 1º fase: Coge directivas de los modulos, (Las que empiezan por '#' en el codigo), como "#include <stdio.h>".
Se ponen los "< >" cuando la libreria esta en la carpeta por defecto. Para coger el que yo quiera #include "asd.h" entre comillas.
Eso lo buscara en el directorio de trabajo y como segunda opcion en el directorio por defecto.
Para saber donde estan los archivos de cabecera de funciones como "printf" o "fork" hay que poner:
	man 3 printf
	man 2 fork
Con el numero especificas donde buscar el archivo dentro del man
- 2º fase: (gcc -E para parar en esta fase)
- 3º fase: (gcc -S para parar en esta fase) Es mas frecuente usarlo para saber que pasa a bajo nivel. (Ensamblador)
- 4º fase: (gcc -c para parar en esta fase)
- "-Wall" para sacar WARNINGS
	Ejemplo: gcc programa.c -Wall -o minishell
		(Esto compila el codigo en programa.c lo llama minishell y saca los WARNINGS)
- "-g" Si usamos el depurador despues debemos de meter el -g.
	(Introduce simbolos que necesita el depurador mas tarde)
- Si se para la compilacion en un punto luego se puede compilar desde ahi
	EJEMPLO: gcc programa.i -o minishell
- "-L" Buscar en el directorio que se indica
	EJEMPLO: gcc programa.c -Wall -L./ -ln -o minishell
- Se pueden mezclar en una compilacion varios archivos compilados a medias, detenidos endistintas fases.
	EJEMPLO: gcc archivo1.i archivo2.o archivo3.s -o archivo
.Formato de un ejecutable
- Numero magico: Identificador que permite determinar si el archivo es ejecutable
- CP(Contador de programa) inicial
- Tabla de secciones: informacion para poder ejecutar el resto del ejecutable
- En un ejecutable NO almacenamos las variables locales, ya que estas se crean dinamicamente (sus direcciones), en la PILA.
.Proceso
	...
.PCB(Bloque de control de procesos)
- Es una estructura de informacion de procesos.
- Contine todo lo que tiene que saber el SO sobre los procesos.
- En Linux el PCB se llama "task_struct".
- Una de las cosas que se guarda en el PCB es la informacion de un proceso cuando se rompe con una interrupcion para retomarlo cuando termine la rutina de la interrupcion.
.Diagrama de estados de un proceso en Linux
- Ejecucion: (TASK_RUNNING) (El "listo" que aparece aqui no es el mismo que hemos visto antes)
- Parado: (TASK_STOPPED) Esta asi cuando esta detenido por una señal(interrupcion software).
- Zombie: (TASK_ZOMBI) Esta asi cuando, cuando ha finalizado, a devuelto todos los recursos, etc. PERO! no se ha eliminado su PCB. El proceso padre es el que se encarga de eliminar el PCB.
	Los procesos ZOMBI hay que evitar tenerlos porque solo ocupan memoria.
- Espera: (TASK_UNINTERRUMPIBLE) Espera por un evento o recurso pero no despierta por ninguna señal.
- Listo: (TASK_INTERRUMPIBLE) Espera por un recurso, etc.
.Espacio de direccionamiento virtual de un proceso
- El SO se encarga de dar la sensacion de que la RAM disponible es mayor. Consigue esto gracias a uso del disco duro.
- Se ejecuta en la memoria RAM solo lo necesario en cuanto a procesos en ese momento, en vez de ejecutar toda la aplicacion en la memoria.
- La MMU traduce direcciones virtuales a fisicas.
.Ejecutable y Mapa de memoria de un proceso
- La pila se asocia al proceso en ejecucion no al ejecutable.
- Heap reserva memoria dinamica. Es memoria que se reserva para los "new" en Java por ejemplo.
- Objeto de memoria es una region de memoria en unejecutable.
- La informacion sobre la memoria que se reserva se extrae del ejecutable. En concreto del objeto de memoria correspondiente.
- La pila no tiene soporte es decir no se crea a partir de algo del ejecutable, depende del sistema.
- Tamaño de las regiones: pueden tener tamaño variable como "heap" y la "pila" o tamaño fijo.
- Se pueden compartir regiones de codigo.
	Ejemplo: dos usuarios de linux usando "vi" a la vez, solo hay una copia del codigo.
.Mapa de memoria de un proceso en UNIX
- Se crea el mapa de memoria mediante fork() y exe().
- fork() crea el proceso.
- exe() ejecuta el proceso.
- Mapa de memoria NO es memoria fisica. Lo crea el SO y lo lleva a memoria segun estan siendo inciciado.
- Contexto de usuario, todas las estructuras axecibles por el usuario y el SO en modo usuario.
- Contexto del nucleo, todas las extructuras axecibles por el nucleo del SO en modo supervisor.
 					
					
				SMILEIS TIME!
		| Contexto de usuario			Contexto nucleo |
----------------|-----------------------------|----------------------------|
Modo supervisor | :) | :) |
----------------|-----------------------------|----------------------------|
Modo usuario 	|	:)		 |		 D: |
----------------|-----------------------------|----------------------------|
- En el contexto de nucleo se encuentran las PCB.
.Mapa de memoria de un proceso en Linux
- En "Sistema(1Gb)" se ecnuentras las PCB
- ESTO NO ES FISICO, EL MAPA DE MEMORIA ES VIRTUAL.
.Servicios POSIX para gestion de procesos
- El servicio POSIX para obtener el identificador de un proceso es getpid()
.Sincronizacion de la ejecucion de un proceso o hilo
- Habra conflicto de sincronizacion cuando los procesos son cooperantes, es decir, dependen unos de otros.
- Como los procesos dependen de otros, un proceso va a depender de la salida de otro.
	(Se habla de procesos pero pueden ser hilos)
- En las soluciones a estos conflictos esta "Productor-Consumidor": Hay un productor que crea informacion y un consumidor que modifica la informacion creada por el productor.
	El "pipe" es un ejemplo de esto. Si la tuberia esta llena el productor no puede dar informacion. Si la tuberia esta vacia el consumidor no puede consumir.
	Por lo que se debe producir antes de consumir.
- Cuando dos procesos o hilos quieren actualizar una misma variable (compartidda) se produce conflictos luego hay que tomar medidas.
- Condicion de carrera: Dos procesos quieren hacer "a++" (modificar la variable), a bajo nivel esto es: - load R0, a
													- add R0, 1
													- store a, R0
	Suponemos que el P1 carga la variable 'a' en R0, hay una interrupcion por el otro proceso, R0 de P1 es 1 (a=1).
	El P2 cumple su funcion sin interrupcion entonces carga 'a' en R0 le suma 1 y la guarda, por lo que a = 2.
	El P1 recupera la ejecucion con R0 = 1 ya cargado, le suma 1 y lo guarda en 'a' como a = 2.
	En este caso la salida no era la esperada (a = 3), por lo que necesitamos un sistema que detenga un proceso hasta que acabe otro.
.Mecanismo de sincronizacion con semaforos
- Solo pueden hacer tres funciones: Inicializacion, Operacion P y Operacion V.
- Operacion P:	Si el semaforo es positivo se decrementa en uno y continua.
	 	Si el semaforo esta a 0, el proceso se bloquea en una lista de espera.	
- Operacion V:	Si el semaforo no tiene procesos
bloqueados se incremente una unidad.
		Si el semaforo tiene procesos bloqueados, despertara al primero que este en esa cola.
- Los mecanismos de sincronizacion deben de ser atomicos, el incremente y decremento del 'P' y 'V' se implementa con servicios atomicos en bajo nivel.
.Solucion consemaforos
(Seccion critica)
- P inicialmente esta a 1. Porque entra el primero pone P a 0 y el otro se encontrara P a 0 y quedara bloqueado.
- Hasta que el primero hace V suponiendo que P2 intenta entrar a la vez se bloquea y V lo desbloqueara. Si no V pondra el semaforo a 1 para que el siguiente proceso tenga P a 1.
(Productor-Consumidor)
- S1 debara ser 0. Asi si el proceso consumidor intenta ejecutarse no podra porque sera P(0). Si el consumidor no intenta entrar durante la ejecucion V pondra S1 a 1 y podra entrar P mas tarde.
.Ejemplo 1
- El hijo es una clonacion del padre por lo que las 'a' son distintas. Si ponemos dos printf despues no sabemos cual se ejecutara primero, solo sabemos que se ejecutara 3 y 4 o 4 y 3.
.Ejemplo 2
- Si el hijo se queda huerfano el init lo adopta y lo cierra por lo que nunca se quedaria zombi.
.Ejemplo 3
- Crea una estructura lineal O-O-O-O-O-O 
.Ejemplo 4
- Crea una estructura a lo ancho |-O
				 O-|-O
				 |-O
Sistemas Operativos/ssoo/tema 3 ssoo/EjercicioMayo2010.pdf
Sistemas Operativos Mayo 2010
Ejercicio de Sistemas Operativos
Parte Práctica
Problema 2
Responda a las siguientes preguntas relativas a los procesos y al API de llamadas al sistema
POSIX relacionadas con procesos.
1. Dado el siguiente programa:
10 #include <stdlib.h>
11 #include <stdio.h>
12
13 int total;
14
15 int calcula(int i) {
16 if (i <= 2) {
17 total = total - (i*100);
18 }
19 }
20
21 int main() {
22 int i ;
23 int pid;
24
25 total =0;
26
27 for (i=0; i < 6 ; i++) {
28 pid=fork ();
29 if (pid ==0) {
30 calcula(i);
31 sleep (1000);
32 }
33 }
34 sleep (10);
35 printf ("El�total�es� %d�\n",total );
36 }
Asumiendo que el tiempo que tarda cada proceso en ejecutar su código es prácticamente
despreciable, ¿se puede precisar qué valor mostraŕıa el mensaje en la ĺınea 35 en el instante
aproximado t = 10? ¿En qué instantes de tiempo aproximadamente finalizaŕıan cada uno
de los procesos presentes en el ejercicio? Razone la respuesta.
2. Considere ahora el siguiente programa:
10 #include <stdlib.h>
11 #include <stdio.h>
12 #include <unistd.h>
13
14 int main() {
15 int i ;
16 int pid;
17
18 for (i=0; i < 6 ; i++) {
19 pid=fork ();
20 if (pid ==0) {
21 execl("/bin/ps","ps","-o","pid ,ppid ,comm",(char *)0);
22 }
23 }
24 sleep (5);
25 printf("Fin�del�proceso� %i�\n",pid);
26 }
La ejecución de la orden ps -o pid,ppid,comm de la ĺınea 21 muestra por pantalla un
listado de todos los procesos lanzados por el usuario correspondiente. Dicho listado es una
tabla con tres columnas indicando el PID, PPID y COMMAND1 de cada uno de los procesos.
Sabiendo que se utiliza una shell bash para ejecutar el programa, que el PID de esa shell
es 7463, que los PID en este sistema se asignan de forma correlativa, que el primer PID
disponible es el 19602, y que no hay nadie más en el sistema creando procesos, ¿cuál seŕıa
la salida por pantalla del programa? Razone la respuesta.
Nota: Recuerde que en UNIX, tal y como está planteado el programa, los posibles procesos
hijo creados no terminarán hasta que no lo haga su padre.
1
COMMAND es el nombre del archivo que contiene el código a ejecutar
6
Sistemas Operativos/ssoo/tema 3 ssoo/EjercicioMayo2012.pdf
Sistemas Operativos Mayo 2012
Ejercicio de Sistemas Operativos
Parte Práctica
Ejercicios sobre procesos en Unix
En cierto sistema similar a UNIX, se ejecutan varias órdenes generando el resultado mostrado
a continuación:
user@host$ cat -n procesos.c
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <unistd.h>
4 #include <sys/types.h>
5 #include <sys/wait.h>
6
7
8 int main () {
9 printf ("A => pid= %d - ppid= %d\n", getpid(), getppid ());
10 if (fork () !=0) {
11 sleep (1);
12 if (fork() !=0) {
13 wait (NULL);
14 wait (NULL);
15 printf ("B => pid= %d - ppid= %d\n", getpid(), getppid ());
16 exit (0);
17 } else {
18 sleep (2);
19 if (fork () ==0) {
20 wait (NULL);
21 sleep (8);
22 printf ("C => pid= %d - ppid= %d\n", getpid(), getppid ());
23 exit (0);
24 } else {
25 sleep (4);
26 printf ("D => pid= %d - ppid= %d\n", getpid(), getppid ());
27 exit (0);
28 }
29 }
30 } else {
31 wait (NULL);
32 sleep (16);
33 printf ("E => pid= %d - ppid= %d\n", getpid(), getppid ());
34 exit (0);
35 }
36 }
user@host$ gcc -Wall -o ejecutable procesos.c
user@host$ ./ ejecutable
A => pid =1000 - ppid =800
...
Teniendo en cuenta que la asignación de PIDs a los nuevos procesos se hace de forma se-
cuencial, que el tiempo de ejecución de las órdenes inmediatas es despreciable y que el primer
mensaje que muestra el programa nada más ejecutarse es el que aparece al final del listado
anterior, responda a las cuestiones siguientes:
1. Rellene la plantilla adjunta con el contenido de los mensajes que aparecen en pantalla. (5
puntos) RESPUESTA:
A ) pid = 1000� ppid = 800
B ) pid = 1000� ppid = 800
C ) pid = 1003� ppid = 1
D ) pid = 1002� ppid = 1000
E ) pid = 1001� ppid = 1000
7
Sistemas Operativos Mayo 2012
2. Rellene la plantilla adjunta con el instante de tiempo en que se muestran los mensajes por
pantalla. (5 puntos)
(10 puntos)
RESPUESTA:
Instante 0 ) Mensaje A
Instante 7 ) Mensaje D
Instante 11 ) Mensaje C
Instante 16 ) Mensaje E
Instante 16 ) Mensaje B
8
Sistemas Operativos/ssoo/tema 3 ssoo/examen_procesos_junio_2010.pdf
Sistemas Operativos Junio 2010
Ejercicio de Sistemas Operativos
Parte Práctica
Problema 1
Dado el siguiente programa:
1 #include <stdio.h>
2 #include <unistd.h>
3 #include <stdlib.h>
4
5 int main()
6 {
7 int id1 , id2 , id3;
8
9 id1 = fork ();
10
11 if (id1 == 0)
12 {
13 sleep (4);
14 printf("Orden�1:� %d� %d\n", getpid(), getppid ());
15 exit (0);
16 }
17
18 else
19 {
20 id2 = fork ();
21 if ( id2 == 0)
22 {
23 id3 = fork ();
24 if (id3 == 0)
25 {
26 sleep (6);
27 printf("Orden�2:� %d� %d\n", getpid(), getppid ());
28 exit (0);
29 }
30 else
31 {
32 printf("Orden�3:� %d� %d\n", getpid(), getppid ());
33 sleep (10);
34 exit (0);
35 }
36 }
37 else
38 {
39 printf("Orden�4:� %d� %d\n", getpid(), getppid ());
40 exit (0);
41 }
42 }
43 }
Responda a las preguntas que a continuación se plantean relativas a su ejecución:
1. Represente un esquema de la jerarqúıa de procesos que se crea cuando se ejecuta el pro-
grama anterior. Indique la relación de parentesco entre procesos de la forma que se indica
en la figura 1, y especifique al lado de cada proceso la ĺınea de código cuya ejecución lo
crea.
Figura 2: Representación de la relación entre proceso padre y proceso hijo.
RESPUESTA:
2. Suponiendo que el PID de la shell que ejecuta el programa es 1967, que no se crean más
procesos que los implicados en la ejecución del programa del enunciado, que los PIDs en
9
Sistemas Operativos Junio 2010
!"#$%&
'()*&+& '()*&,&
'()*&-&
Línea 9 Línea 
20 
Línea 
23 
Figura 3: Jerarqúıa de procesos.
este sistema se asignan correlativamente, y que el primer PID disponible es 2890, indique
cuál seŕıa la salida por pantalla al ejecutarse el programa anterior2
RESPUESTA: Suponiendo que el tiempo de ejecución de las llamadas a fun-
ciones (excepto las invocaciones al servicio POSIX sleep()) es despreciable,
las ĺıneas que se obtendŕıan por pantalla seŕıan las siguientes:
Orden 4: 2890 1967
Orden 3: 2892 1
Orden 1: 2891 1
Orden 2: 2893 2892
3. Si añadiéramos en el código del programa una variable global i inicializada a 0 y susti-
tuyéramos cada ĺınea printf() por las ĺıneas siguientes:
i=i+1;
printf(‘‘Orden %d: %d %d’’, i, getpid(), getppid())
¿Qué valores de i saldŕıan en pantalla? Razone la respuesta.
RESPUESTA: Cada proceso que se crea tiene una copia propia del área de da-
tos globales del
proceso padre. Por lo tanto, el cambio realizado sólo originaŕıa
ĺıneas cuyo valor de i seŕıa siempre 1, que no es la secuencia que se generaŕıa
con la alternativa del código inicial
4. Se ha realizado independientemente un programa denominado MapaDeMemoria que se en-
carga de visualizar en pantalla el mapa de memoria actual del proceso que lo invoca. La
forma de ejecutar este programa es la siguiente:
$ MapaDeMemoria
Si el proceso que ejecuta la ĺınea 14 se tuviera que encargar, además, de ejecutar el pro-
grama MapaDeMemoria, ¿qué nuevas instrucciones habŕıa que añadir al código existente y
en qué lugar? Razone la respuesta.
RESPUESTA: Si tiene que ejecutar el nuevo programa, tenemos que utilizar
cualquier servicio POSIX de la familia exec, por ejemplo, execl. Además, se
2NOTAS:
En UNIX, si un proceso padre finaliza antes que sus procesos hijos, estos procesos son adoptados por el
proceso init ; a partir de ese instante, init es el nuevo proceso padre de estos procesos hijos.
Los servicios POSIX getpid() y getppid() devuelven el identificador del proceso, y el identificador del
proceso padre respectivamente.
10
Sistemas Operativos Junio 2010
debe invocar tras la ĺınea 14, porque después no se ejecutarán más sentencias
del código de este programa. Por lo tanto, en la ĺınea 15 se añadiŕıa lo siguiente:
execl("./MapaDeMemoria", "./MapaDeMemoria", NULL);
5. ¿Se podŕıa garantizar con el uso de las llamadas wait, exit, fork y exec que el orden de
aparición de las ĺıneas en pantalla fuera secuencial y ascendente (Orden1, Orden2, Orden3,
etc.)? Razone la respuesta y, en caso afirmativo, indique cómo.
RESPUESTA: Śı, ejecutando el proceso padre en la ĺınea 39, antes de la invocación a
printf():
wait(NULL);
wait(NULL);
De este modo, el proceso padre, que imprime Orden 4, espera a sus dos procesos hijos y,
además, para que el proceso creado al ejecutarse la ĺınea 20 esperase, a su vez, a su proceso
hijo, se añadiŕıa en la ĺınea 32, antes de la invocación a printf(), la siguiente ĺınea:
wait(NULL);
11
Sistemas Operativos/ssoo/tema 3 ssoo/minishell.1/archivos_de_apoyo_ejercicio2.zip
ejecutar.h
pid_t ejecutar_orden(const char *orden, int *pbackgr);
void ejecutar_linea_ordenes(const char *orden);
__MACOSX/._ejecutar.h
entrada_minishell.c
#include "entrada_minishell.h"
void imprimir_prompt()
{
 printf("minishell> "); /* se imprime en pantalla una cadena sencilla que servirá de prompt: entrada de órdenes en la consola */
 fflush(stdout); /* vacía el buffer intermedio de salida y se envía el texto a la pantalla */
}
void eliminar_salto_linea(char *cad)
{
 int i, longitud;
 longitud=strlen(cad); /* cad es una cadena de caracteres con la orden leída.*/
 for(i=longitud-1; i>=0;i--) /* se busca el carácter de final de línea introducido por fgets y se sustituye por '\0' para indicar el final de orden */
 if (cad[i]=='\n') 
 {
 cad[i]=0;
 break;
 }
}
 
void leer_linea_ordenes(char *buf)
{
 
 memset(buf, 0, sizeof(buf));
 fgets(buf, BUFSIZ-1, stdin); /* fgets almacena la orden leída introduciendo también el carácter de fin de línea introducido */
 buf[BUFSIZ-1]=0; /* se almacena el carácter de fin de cadena al final de buf porque va a ser tratada por eliminar_salto_linea como cadena */
 eliminar_salto_linea(buf); 
}
__MACOSX/._entrada_minishell.c
internas.h
#ifndef INTERNAS_H
#define INTERNAS_H
struct tipointerna
{
 char *nombre;
 void (*func)(const char *);
};
int ord_interna(const char *);
#endif
libmemoria.c
#include "libmemoria.h"
#include "stdlib.h"
//#include "malloc.h"
void free_argumentos(char **args)
{
 int i=0;
 while(args[i])
 free(args[i++]);
 free(args);
}
__MACOSX/._libmemoria.c
libmemoria.h
void free_argumentos(char **args);
minishell.h
#ifndef MINISHELL_H
#define MINISHELL_H
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <signal.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>
#endif
void imprimir_prompt();
void eliminar_salto_linea(char *cad);
void leer_linea_ordenes(char *buf);
__MACOSX/._minishell.h
parser.h
enum TEstado {
 INICIO_ARG, ARG
};
 
char ** parser_orden (const char *orden, int *indentrada, int *indsalida, int *background);
Sistemas Operativos/ssoo/tema 3 ssoo/minishell.1/ejecutar.c#include "minishell.h"
#include "parser.h"
#include "ejecutar.h"
#include "libmemoria.h"
pid_t ejecutar_orden (const char *orden, int *pbackgr)
{
	char **args;
	pid_t pid;
	int indice_entrada=-1,indice_salida=-1;
	if ((args=parser_orden (orden,&indice_entrada,&indice_salida,pbackgr)==NULL)) 			{
			printf ("vacio");			
			return -1;
		}
	
	
	printf ("ejecutar");
	
printf ("ejecutar2");
	free_argumentos(args);
}
void ejecutar_linea_ordenes (const char *orden)
{
	pid_t pid;
	int backgr=0;
	pid=ejecutar_orden(orden,&backgr);
}
Sistemas Operativos/ssoo/tema 3 ssoo/minishell.1/ejecutar.hpid_t ejecutar_orden(const char *orden, int *pbackgr);
void ejecutar_linea_ordenes(const char *orden);
Sistemas Operativos/ssoo/tema 3 ssoo/minishell.1/entrada_minishell.c#include "entrada_minishell.h"
#include <stdio.h>
#include <string.h>
void imprimir_prompt()
{
 printf("minishell> "); /* se imprime en pantalla una cadena sencilla que servirá de prompt: entrada de órdenes en la consola */
 fflush(stdout); /* vacía el buffer intermedio de salida y se envía el texto a la pantalla */
}
void eliminar_salto_linea(char *cad)
{
 int i, longitud;
 longitud=strlen(cad); /* cad es una cadena de caracteres con la orden leída.*/
 for(i=longitud-1; i>=0;i--) /* se busca el carácter de final de línea introducido por fgets y se sustituye por '\0' para indicar el final de orden */
 if (cad[i]=='\n') 
 {
 cad[i]=0;
 break;
 }
}
 
void leer_linea_ordenes(char *buf)
{
 
 memset(buf, 0, sizeof(buf));
 fgets(buf, BUFSIZ-1, stdin); /* fgets almacena la orden leída introduciendo también el carácter de fin de línea introducido */
 buf[BUFSIZ-1]=0; /* se almacena el carácter de fin de cadena al final de buf porque va a ser tratada por eliminar_salto_linea como cadena */
 eliminar_salto_linea(buf); 
}
Sistemas Operativos/ssoo/tema 3 ssoo/minishell.1/entrada_minishell.hvoid imprimir_prompt();
void eliminar_salto_linea(char *cad);
void leer_linea_ordenes(char *buf);
Sistemas Operativos/ssoo/tema 3 ssoo/minishell.1/internas.h#ifndef INTERNAS_H
#define INTERNAS_H
struct tipointerna
{
 char *nombre;
 void (*func)(const char *);
};
int ord_interna(const char *);
#endif
Sistemas Operativos/ssoo/tema 3 ssoo/minishell.1/libmemoria.c#include "libmemoria.h"
#include "stdlib.h"
#include "malloc.h"
void free_argumentos(char **args)
{
 int i=0;
 while(args[i])
 free(args[i++]);
 free(args);
}
Sistemas Operativos/ssoo/tema 3 ssoo/minishell.1/libmemoria.h
void free_argumentos(char **args);
Sistemas Operativos/ssoo/tema 3 ssoo/minishell.1/libshell.a
internas.o
parser.o
Sistemas Operativos/ssoo/tema 3 ssoo/minishell.1/minishell.c#include "minishell.h"
#include "internas.h"
#include "ejecutar.h"
#include <string.h>
int main (int argc, char *argv[])
{
	char buf [BUFSIZ];
	while (1)
	{
		imprimir_prompt();
		leer_linea_ordenes(buf);
		printf ("%s \n",buf);
		if (strcmp(buf,"exit")==0) 
		{
			break;		
		}
		else
		{
			if (ord_interna(buf)!=1)
			{ 
				printf ("orden externa");
				ejecutar_linea_ordenes (buf);
			}
			
			printf ("minishell \n");
		}
	}
	return 0;
}
			
Sistemas Operativos/ssoo/tema 3 ssoo/minishell.1/minishell.h#ifndef MINISHELL_H
#define MINISHELL_H
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <signal.h>
#include
<errno.h>
#include <unistd.h>
#include <string.h>
#endif
void imprimir_prompt();
void eliminar_salto_linea(char *cad);
void leer_linea_ordenes(char *buf);
Sistemas Operativos/ssoo/tema 3 ssoo/minishell.1/minishell.zip
test
prueba
parser.h
enum TEstado {
 INICIO_ARG, ARG
};
 
char ** parser_orden (const char *orden, int *indentrada, int *indsalida, int *background);
minishell.h
#ifndef MINISHELL_H
#define MINISHELL_H
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <signal.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>
#endif
void imprimir_prompt();
void eliminar_salto_linea(char *cad);
void leer_linea_ordenes(char *buf);
minishell.c
#include "minishell.h"
#include "internas.h"
#include "ejecutar.h"
#include <string.h>
int main (int argc, char *argv[])
{
	char buf [BUFSIZ];
	while (1)
	{
		imprimir_prompt();
		leer_linea_ordenes(buf);
		printf ("%s \n",buf);
		if (strcmp(buf,"exit")==0) 
		{
			break;		
		}
		else
		{
			if (ord_interna(buf)!=1)
			{ 
				printf ("orden externa");
				ejecutar_linea_ordenes (buf);
			}
			
			printf ("minishell \n");
		}
	}
	return 0;
}
			
libshell.a
internas.o
parser.o
libmemoria.h
void free_argumentos(char **args);
libmemoria.c
#include "libmemoria.h"
#include "stdlib.h"
#include "malloc.h"
void free_argumentos(char **args)
{
 int i=0;
 while(args[i])
 free(args[i++]);
 free(args);
}
internas.h
#ifndef INTERNAS_H
#define INTERNAS_H
struct tipointerna
{
 char *nombre;
 void (*func)(const char *);
};
int ord_interna(const char *);
#endif
entrada_minishell.h
void imprimir_prompt();
void eliminar_salto_linea(char *cad);
void leer_linea_ordenes(char *buf);
entrada_minishell.c
#include "entrada_minishell.h"
#include <stdio.h>
#include <string.h>
void imprimir_prompt()
{
 printf("minishell> "); /* se imprime en pantalla una cadena sencilla que servirá de prompt: entrada de órdenes en la consola */
 fflush(stdout); /* vacía el buffer intermedio de salida y se envía el texto a la pantalla */
}
void eliminar_salto_linea(char *cad)
{
 int i, longitud;
 longitud=strlen(cad); /* cad es una cadena de caracteres con la orden leída.*/
 for(i=longitud-1; i>=0;i--) /* se busca el carácter de final de línea introducido por fgets y se sustituye por '\0' para indicar el final de orden */
 if (cad[i]=='\n') 
 {
 cad[i]=0;
 break;
 }
}
 
void leer_linea_ordenes(char *buf)
{
 
 memset(buf, 0, sizeof(buf));
 fgets(buf, BUFSIZ-1, stdin); /* fgets almacena la orden leída introduciendo también el carácter de fin de línea introducido */
 buf[BUFSIZ-1]=0; /* se almacena el carácter de fin de cadena al final de buf porque va a ser tratada por eliminar_salto_linea como cadena */
 eliminar_salto_linea(buf); 
}
ejecutar.h
pid_t ejecutar_orden(const char *orden, int *pbackgr);
void ejecutar_linea_ordenes(const char *orden);
ejecutar.c
#include "minishell.h"
#include "parser.h"
#include "ejecutar.h"
#include "libmemoria.h"
pid_t ejecutar_orden (const char *orden, int *pbackgr)
{
	char **args;
	pid_t pid;
	int indice_entrada=-1,indice_salida=-1;
	if ((args=parser_orden (orden,&indice_entrada,&indice_salida,pbackgr)==NULL)) 			{
			printf ("vacio");			
			return -1;
		}
	
	
	printf ("ejecutar");
	
printf ("ejecutar2");
	free_argumentos(args);
}
void ejecutar_linea_ordenes (const char *orden)
{
	pid_t pid;
	int backgr=0;
	pid=ejecutar_orden(orden,&backgr);
}
archivos_de_apoyo_ejercicio2.zip
ejecutar.h
pid_t ejecutar_orden(const char *orden, int *pbackgr);
void ejecutar_linea_ordenes(const char *orden);
__MACOSX/._ejecutar.h
entrada_minishell.c
#include "entrada_minishell.h"
void imprimir_prompt()
{
 printf("minishell> "); /* se imprime en pantalla una cadena sencilla que servirá de prompt: entrada de órdenes en la consola */
 fflush(stdout); /* vacía el buffer intermedio de salida y se envía el texto a la pantalla */
}
void eliminar_salto_linea(char *cad)
{
 int i, longitud;
 longitud=strlen(cad); /* cad es una cadena de caracteres con la orden leída.*/
 for(i=longitud-1; i>=0;i--) /* se busca el carácter de final de línea introducido por fgets y se sustituye por '\0' para indicar el final de orden */
 if (cad[i]=='\n') 
 {
 cad[i]=0;
 break;
 }
}
 
void leer_linea_ordenes(char *buf)
{
 
 memset(buf, 0, sizeof(buf));
 fgets(buf, BUFSIZ-1, stdin); /* fgets almacena la orden leída introduciendo también el carácter de fin de línea introducido */
 buf[BUFSIZ-1]=0; /* se almacena el carácter de fin de cadena al final de buf porque va a ser tratada por eliminar_salto_linea como cadena */
 eliminar_salto_linea(buf); 
}
__MACOSX/._entrada_minishell.c
internas.h
#ifndef INTERNAS_H
#define INTERNAS_H
struct tipointerna
{
 char *nombre;
 void (*func)(const char *);
};
int ord_interna(const char *);
#endif
libmemoria.c
#include "libmemoria.h"
#include "stdlib.h"
//#include "malloc.h"
void free_argumentos(char **args)
{
 int i=0;
 while(args[i])
 free(args[i++]);
 free(args);
}
__MACOSX/._libmemoria.c
libmemoria.h
void free_argumentos(char **args);
minishell.h
#ifndef MINISHELL_H
#define MINISHELL_H
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <signal.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>
#endif
void imprimir_prompt();
void eliminar_salto_linea(char *cad);
void leer_linea_ordenes(char *buf);
__MACOSX/._minishell.h
parser.h
enum TEstado {
 INICIO_ARG, ARG
};
 
char ** parser_orden (const char *orden, int *indentrada, int *indsalida, int *background);
__MACOSX/._ejecutar.h
__MACOSX/._entrada_minishell.c
__MACOSX/._libmemoria.c
__MACOSX/._minishell.h
Sistemas Operativos/ssoo/tema 3 ssoo/minishell.1/parser.henum TEstado {
 INICIO_ARG, ARG
};
 
char ** parser_orden (const char *orden, int *indentrada, int *indsalida, int *background);
Sistemas Operativos/ssoo/tema 3 ssoo/minishell.1/prueba
Sistemas Operativos/ssoo/tema 3 ssoo/minishell.1/test
Sistemas Operativos/ssoo/tema 3 ssoo/minishell.1/__MACOSX/._ejecutar.h
Sistemas Operativos/ssoo/tema 3 ssoo/minishell.1/__MACOSX/._entrada_minishell.c
Sistemas Operativos/ssoo/tema 3 ssoo/minishell.1/__MACOSX/._libmemoria.c
Sistemas Operativos/ssoo/tema 3 ssoo/minishell.1/__MACOSX/._minishell.h
Sistemas Operativos/ssoo/tema 3 ssoo/procesos.pdf
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Procesos e Hilos
Departamento de Automática
Universidad de Alcalá
Sistemas Operativos Procesos e Hilos 1 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Índice
1 Programa
Concepto de programa
Fases de desarrollo de un programa
Formato de un ejecutable
2 Procesos
Concepto y características
Bloque de control de proceso
Estados de un proceso
Mapa de memoria de un proceso
3 Servicios POSIX para gestión de procesos
Creación de un proceso
Ejecución de un programa
Finalización de un proceso
Espera por la finalización de un proceso
4 Hilos
Objetivo, concepto y características
Implementación y programación
Hilos vs. procesos
Ejemplo de programación con hilos
5 Sincronización de Procesos/Hilos
Motivos
Sincronización con semáforos
Sistemas Operativos Procesos e Hilos 2 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Concepto y características de un programa
Fases de desarrollo de un programa
Formato de un ejecutable
Concepto y características de un programa
Programa
Un programa
es una colección de instrucciones y de datos
almacenados en un archivo ordinario.
Características de un programa
Residen en dispositivos de almacenamiento permanente.
Generalmente, para ser ejecutados deben residir en MP.
Entidad estática.
Sistemas Operativos Procesos e Hilos 3 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Concepto y características de un programa
Fases de desarrollo de un programa
Formato de un ejecutable
Fases de desarrollo de un programa
Ciclo de desarrollo
1 Edición.
2 Compilación.
3 Ejecución.
4 Depuración.
Sistemas Operativos Procesos e Hilos 4 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Concepto y características de un programa
Fases de desarrollo de un programa
Formato de un ejecutable
Fases de desarrollo de un programa
Generación de un ejecutable
Sistemas Operativos Procesos e Hilos 5 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Concepto y características de un programa
Fases de desarrollo de un programa
Formato de un ejecutable
Fases de desarrollo de un programa en UNIX
vi, vim, emacs, gedit, etc. cc (gcc), make, ar, 
etc.
$ vi enteros.c $ gcc enteros.c –o enteros
gdb, ddd
$ gdb enteros
Edición Compilación Depuración
vi, vim, emacs, gedit, etc.vi, vim, emacs, gedit, etc. cc (gcc), make, ar, 
etc.
cc (gcc), make, ar, 
etc.
$ vi enteros.c $ gcc enteros.c –o enteros
gdb, ddd
$ gdb enteros
Edición Compilación Depuración
Sistemas Operativos Procesos e Hilos 6 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Concepto y características de un programa
Fases de desarrollo de un programa
Formato de un ejecutable
Fases de desarrollo de un programa en UNIX
Compilación
cppcpp ldldcompcomp
programa.c programa.i programa.s programa.o a.out
Preprocesamiento Compilación
y optimización
Generación
de código objeto
Enlace
gcc
asascppcpp ldldcompcomp
programa.c programa.i programa.s programa.o a.out
Preprocesamiento Compilación
y optimización
Generación
de código objeto
Enlace
gcc
asas
La orden gcc tiene opciones para generar los archivos
intermedios (-E, -S, -c).
Otras opciones de gcc: -o, -Wall, -g, etc.
Sistemas Operativos Procesos e Hilos 7 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Concepto y características de un programa
Fases de desarrollo de un programa
Formato de un ejecutable
Fases de desarrollo de un programa en UNIX
Ejemplo 1
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int imprimir = 1;
char *nomprog;
int main(int argc,
char *argv[])
{
int i;
int *ptr;
nomprog = argv[0];
printf("Núm. de args = %d", argc);
printf("Nombre del prog.: %s\n",
nomprog);
for (i=1; i <argc; i++)
{
ptr = malloc(strlen(argv[i])+1);
strcpy(ptr, argv[i]);
if (imprimir) printf("%s\n", ptr);
free(ptr);
}
return 0;
} /* fin main */
Sistemas Operativos Procesos e Hilos 8 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Concepto y características de un programa
Fases de desarrollo de un programa
Formato de un ejecutable
Fases de desarrollo de un programa en UNIX
Compilación de varios módulos
stdio.h math.h arch1.h 
cpp comp as 
st	
  arch1.c 
st	
  
st	
  
Editor 
 vi 
arch2.c 
arch3.c 
arch1.o 
arch2.o 
arch3.o 
Enlazador 
 ld 
gcc 
Archivos de 
cabecera 
archej 
Bibliotecas libc.a libm.a 
Sistemas Operativos Procesos e Hilos 9 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Concepto y características de un programa
Fases de desarrollo de un programa
Formato de un ejecutable
Formato de un ejecutable
´
Número mágico
CP inicial
Tabla de secciones
Código
Datos iniciados
Tabla de símbolos
Archivo ejecutable
Código 1000 3000
Datos inic. 4000 1000
Datos sin inic. - 100
T. Símbolos 7000 1000
0
1000
4000
7000
C
a
b
e
c
e
ra
C
a
b
e
c
e
ra
S
e
c
c
io
n
e
s
S
e
c
c
io
n
e
s
Desplaz. Tam.
´
Número mágico
CP inicial
Tabla de secciones
Código
Datos iniciados
Tabla de símbolos
Archivo ejecutable
Código 1000 3000
Datos inic. 4000 1000
Datos sin inic. - 100
T. Símbolos 7000 1000
0
1000
4000
7000
C
a
b
e
c
e
ra
C
a
b
e
c
e
ra
S
e
c
c
io
n
e
s
S
e
c
c
io
n
e
s
Desplaz. Tam.
⇒ Formatos: ELF, EXE, COM, etc.
Sistemas Operativos Procesos e Hilos 10 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Concepto y características
Bloque de control de proceso
Estados de un proceso
Mapa de memoria de un proceso
Proceso
Concepto de proceso
Un proceso es un programa en ejecución.
Características de un proceso
Entidad dinámica.
Los procesos se componen de: código, datos, pila, heap, etc.
El sistema operativo le asigna recursos: CPU, memoria,
archivos, etc.
El sistema operativo controla su ejecución.
El sistema operativo lleva la contabilidad de todos los
procesos existentes en el sistema.
⇒ Varios procesos pueden ejecutar el mismo programa.
⇒ Un proceso puede derivar de otro proceso.Sistemas Operativos Procesos e Hilos 11 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Concepto y características
Bloque de control de proceso
Estados de un proceso
Mapa de memoria de un proceso
Procesos en UNIX
Cada proceso tiene un identificador único denominado PID.
Los procesos forman una jerarquía de procesos cuya raíz es el
proceso init.
init es el primer proceso que arranca en UNIX.
Su PID es 1.
La función principal de init es arrancar distintos procesos, por
ejemplo, login.
El PPID de un proceso es el PID de su proceso padre.
Sistemas Operativos Procesos e Hilos 12 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Concepto y características
Bloque de control de proceso
Estados de un proceso
Mapa de memoria de un proceso
Bloque de control de proceso (PCB)
Concepto
El PCB es una estructura de datos con información de un proceso.
El PCB contiene información referente a:
Estado actual del proceso.
Identificación unívoca del proceso.
Prioridad del proceso.
Puntero a la zona de memoria asignada.
Punteros a los recursos asociados.
Área de salvaguarda de registros.
Un puntero al siguiente PCB, formando una lista enlazada.
⇒ En Linux, el PCB se denomina task_struct
Sistemas Operativos Procesos e Hilos 13 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Concepto y características
Bloque de control de proceso
Estados de un proceso
Mapa de memoria de un proceso
Diagrama de estados de un proceso en Linux
Sistemas Operativos Procesos e Hilos 14 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Concepto y características
Bloque de control de proceso
Estados de un proceso
Mapa de memoria de un proceso
Espacio de direccionamiento virtual de un proceso
Memoria
física
Código
Espacio de direccionamiento
virtual de la
aplicación A
Espacio de direccionamiento
real
MMUMMU
AA
BB
CC
DD
EE
FF
GG AA
BB
CC
EE
CódigoAA
BB
CC
DD
EE
FF
GG
AA
Tabla de
traducción
de A
Tabla de
traducción
de B
MMUMMU
Memoria
física
Código
virtual de la
aplicación A
Espacio de direccionamiento
real
MMUMMU
AA
BB
CC
DD
EE
FF
GG AA
BB
CC
EE
CódigoAA
BB
CC
DD
EE
FF
GG
AA
Tabla de
traducción
de A
Tabla de
traducción
de B
MMUMMU
Espacio de direccionamiento
virtual de la
aplicación B
Espacio de direccionamiento
virtual de la
aplicación 
Memoria
física
Código
Espacio de direccionamiento
virtual de la
aplicación A
Espacio de direccionamiento
real
MMUMMU
AA
BB
CC
DD
EE
FF
GG
AA
BB
CC
EE
CódigoAA
BB
CC
DD
EE
FF
GG
AA
Tabla de
traducción
de A
Tabla de
traducción
de B
MMUMMU
Memoria
física
Código
virtual de la
aplicación A
Espacio de direccionamiento
real
MMUMMU
AA
BB
CC
DD
EE
FF
GG AA
BB
CC
EE
CódigoAA
BB
CC
DD
EE
FF
GG
AA
Tabla de
traducción
de A
Tabla de
traducción
de B
MMUMMU
Espacio de direccionamiento
virtual de la
aplicación B
Espacio de direccionamiento
virtual de la
aplicación 
Sistemas Operativos Procesos e Hilos 15 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Concepto y características
Bloque de control de proceso
Estados de un proceso
Mapa de memoria de un proceso
Ejecutable y Mapa de memoria de un proceso
´
Código
Datos iniciados
Datos no iniciados
Heap
Archivo X proyectado
Zona compartida
Código biblioteca dinámica Z
Datos biblioteca dinámica Z
Pila de hilo 1
Pila 
´
Código
Datos iniciados
Datos no iniciados
Heap
Archivo X proyectado
Zona compartida
Código biblioteca dinámica Z
Datos biblioteca dinámica Z
Pila de hilo 1
Pila 
´
Número mágico
CP inicial
Tabla de secciones
Código
Datos iniciados
Tabla de símbolos
´
Número mágico
CP inicial
Tabla de secciones
Código
Datos iniciados
Tabla de símbolos
Archivo ejecutable
0
1000
4000
7000
C
a
b
e
c
e
ra
C
a
b
e
c
e
ra
S
e
c
c
io
n
e
s
S
e
c
c
io
n
e
s
2000
5000
6000
Mapa de memoria
P
o
s
ib
le
s
 r
e
g
io
n
e
s
 c
re
a
d
a
s
 e
n
 
ti
e
m
p
o
 d
e
 e
je
c
u
c
ió
n
´
Código
Datos iniciados
Datos no iniciados
Heap
Archivo X proyectado
Zona compartida
Código biblioteca dinámica Z
Datos biblioteca dinámica Z
Pila de hilo 1
Pila 
´
Código
Datos iniciados
Datos no iniciados
Heap
Archivo X proyectado
Zona compartida
Código biblioteca dinámica Z
Datos biblioteca dinámica Z
Pila de hilo 1
Pila 
´
Número mágico
CP inicial
Tabla de secciones
Código
Datos iniciados
Tabla de símbolos
´
Número mágico
CP inicial
Tabla de secciones
Código
Datos iniciados
Tabla de símbolos
Archivo ejecutable
0
1000
4000
7000
C
a
b
e
c
e
ra
C
a
b
e
c
e
ra
S
e
c
c
io
n
e
s
S
e
c
c
io
n
e
s
2000
5000
6000
Mapa de memoria
P
o
s
ib
le
s
 r
e
g
io
n
e
s
 c
re
a
d
a
s
 e
n
 
ti
e
m
p
o
 d
e
 e
je
c
u
c
ió
n
⇒ Propiedades de la región: Soporte (archivo/anónimo),
compartición, protección, y tamaño.
Sistemas Operativos Procesos e Hilos 16 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Concepto y características
Bloque de control de proceso
Estados de un proceso
Mapa de memoria de un proceso
Mapa de memoria de un proceso en UNIX
Contexto de usuario Contexto del núcleo
Datos del núcleoTexto (código)
Datos iniciados de
sólo lectura
Datos iniciados de
lectura-escritura
Datos no iniciados
Área dinámica (heap)
Pila
Contexto de usuario Contexto del núcleo
Datos del núcleoTexto (código)
Datos iniciados de
sólo lectura
Datos iniciados de
lectura-escritura
Datos no iniciados
Área dinámica (heap)
Pila
Texto (código)
Datos iniciados de
sólo lectura
Datos iniciados de
lectura-escritura
Datos no iniciados
Área dinámica (heap)
Pila
⇒ ¿Qué contendrá cada región del mapa en el caso del ejemplo 1?
⇒ ¿Qué relación existe entre el contexto del proceso y del núcleo con
el modo de ejecución?Sistemas Operativos Procesos e Hilos 17 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Concepto y características
Bloque de control de proceso
Estados de un proceso
Mapa de memoria de un proceso
Mapa de memoria de un proceso en Linux
Cabecera
0x40000000
Código (Text)
Datos (Data)
Datos no iniciados (BSS)
start_code
end_code
end_data
end_bss
Bibliotecas
compartidas
Cabecera
0x80000000
Código (Text)
Sistema (1 Gb)
Datos no iniciados (BSS)
start_code
end_code
end_data
end_bss
Programa
Información para carga dinámica
0xBFFFFFB
Argumentos
Variables de entorno
Archivo del programa
arg_start
env_start
Puntero a los argumentos 
y variables de entorno
start_stack
Datos (Data)
0x00000000
0x40000000
0xFFFFFFFF
0x3FFFFFFF
Usuario (3 Gb) P
R
O
Y
E
C
C
IÓ
N
P
R
O
Y
E
C
C
IÓ
N
Cabecera
0x40000000
Código (Text)
Datos (Data)
Datos no iniciados (BSS)
start_code
end_code
end_data
end_bss
Bibliotecas
compartidas
Cabecera
0x80000000
Código (Text)
Sistema (1 Gb)
Datos no iniciados (BSS)
start_code
end_code
end_data
end_bss
Programa
Información para carga dinámica
0xBFFFFFB
Argumentos
Variables de entorno
Archivo del programa
arg_start
env_start
Puntero a los argumentos 
y variables de entorno
start_stack
Datos (Data)
0x00000000
0x40000000
0xFFFFFFFF
0x3FFFFFFF
Usuario (3 Gb) P
R
O
Y
E
C
C
IÓ
N
P
R
O
Y
E
C
C
IÓ
N
Sistemas Operativos Procesos e Hilos 18 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Concepto y características
Bloque de control de proceso
Estados de un proceso
Mapa de memoria de un proceso
Mapa de memoria de un proceso en Windows
Usuario (2 Gb)
Código .EXE
Pilas de cada thread
Heap
Código .DLL
Sistema (2 Gb)
Ejecutivo, kernel, HAL,
drivers, pilas del núcleo
para cada hilo
Win32K.sys
0x00000000
0x80000000
0xFFFFFFFF
0x7FFFFFFF
Tabla de páginas
Cache del sistema 
de archivos
Usuario (2 Gb)
Código .EXE
Pilas de cada thread
Heap
Código .DLL
Sistema (2 Gb)
Ejecutivo, kernel, HAL,
drivers, pilas del núcleo
para cada hilo
Win32K.sys
0x00000000
0x80000000
0xFFFFFFFF
0x7FFFFFFF
Tabla de páginas
Cache del sistema 
de archivos
Sistemas Operativos Procesos e Hilos 19 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Creación de un proceso
Ejecución de un programa
Finalización de un proceso
Espera por la finalización de un proceso
Servicios POSIX para gestión de procesos
Uso de los servicios POSIX para gestión de procesos
Creación de procesos
Ejecución de un programa
Finalización de procesos
Identificación de procesos
Gestión del entorno de procesos
Sistemas Operativos Procesos e Hilos 20 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Creación de un proceso
Ejecución de un programa
Finalización de un proceso
Espera por la finalización de un proceso
Creación de un proceso
Esquema
Imagen Imagen 
de PAde PA
fork()
Mapa de memoria
Mapa de memoria Lista de PCB’s
Imagen Imagen 
de PAde PA
Imagen Imagen 
de PBde PB Secciones compartidas: 
código o zonas de memoria
PCBPCBPAPA
Lista de PCB’s
PCBPCBPAPA PCBPCBPBPB
PID PID
Imagen Imagen 
de PAde PA
fork()
Mapa de memoria
Mapa de memoria Lista de PCB’s
Imagen Imagen 
de PAde PA
Imagen Imagen 
de PBde PB Secciones compartidas: 
código o zonas de memoria
PCBPCBPAPA
Lista de PCB’s
PCBPCBPAPA PCBPCBPBPB
PID PID
Sistemas Operativos Procesos e Hilos 21 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Creación de un proceso
Ejecución de un programa
Finalización de un proceso
Espera por la finalización de un proceso
Creación de un proceso
Servicio POSIX
Prototipo
pid_t fork();
Descripción
Crea una copia (proceso hijo) del proceso que la invoca
(proceso padre)
Devuelve
Si la llamada se ejecuta correctamente:
⇒ Al padre: el pid del proceso hijo
⇒ Al hijo: 0
En caso contrario: -1 y en la variable global errno el código
del error
Sistemas Operativos Procesos e Hilos 22 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Creación de un proceso
Ejecución de un programa
Finalización de un proceso
Espera por la finalización de un proceso
Creación de un proceso
Ejemplo
#include <sys/types.h>
#include <stdio.h>
int main(void)
{
pid_t id;
id = fork();
if(id == -1) {
perror(”Error en el fork");
exit(1);
}
if (id == 0) {
while (1) printf("Hola:
soy el hijo\n");
}
else {
while (1) printf("Hola: soy el padre\n");
}
}
Sistemas Operativos Procesos e Hilos 23 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Creación de un proceso
Ejecución de un programa
Finalización de un proceso
Espera por la finalización de un proceso
Ejecución de un programa
Esquema
Imagen Imagen 
de PAde PA
exec()
Mapa de memoria
Mapa de memoria Lista de PCB’s
PCBPCBPAPA
Lista de PCB’s
PCBPCBPAPA
Imagen Imagen 
de PAde PA
Biblioteca del
sistema
Ejecutable
Cargador
Imagen Imagen 
de PAde PA
exec()
Mapa de memoria
Mapa de memoria Lista de PCB’s
PCBPCBPAPA
Lista de PCB’s
PCBPCBPAPA
Imagen Imagen 
de PAde PA
Biblioteca del
sistema
Ejecutable
Cargador
Sistemas Operativos Procesos e Hilos 24 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Creación de un proceso
Ejecución de un programa
Finalización de un proceso
Espera por la finalización de un proceso
Ejecución de un programa
Servicio POSIX
Prototipo
int execl (const char *path, const char *arg, ...);
int execlp (const char *file, const char *arg, ...);
int execv (const char *path, char const *argv[]);
int execvp (const char *file, char const *argv[]);
int exccve (const char *path, char *argv[], char *
const envp[]);
Descripción
Reemplazan la imagen del proceso actual por la imagen de un
proceso a partir de un archivo ejecutable
Devuelve
Si hay error: -1 y en la variable global errno el código del
error Sistemas Operativos Procesos e Hilos 25 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Creación de un proceso
Ejecución de un programa
Finalización de un proceso
Espera por la finalización de un proceso
Ejecución de un programa
Ejemplo
#include <unistd.h>
#include <stdio.h>
int main(void)
{
pid_t id;
char *args[3];
args[0] = "ps";
args[1] = ”-l";
args[2] = NULL;
if (execvp(args[0], args) < 0) {
perror(”Error en execvp");
exit(-1);
}
}
Sistemas Operativos Procesos e Hilos 26 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Creación de un proceso
Ejecución de un programa
Finalización de un proceso
Espera por la finalización de un proceso
Finalización de un proceso
Servicio POSIX
Prototipo
void exit(int status);
Descripción
Termina la ejecución de un proceso. El proceso da una
indicación de cómo finalizó mediante status
Cuando un proceso termina, sus hijos no mueren y suelen ser
adoptados por el proceso init
El valor de status es retornado al proceso padre (¡si existe!)
Sistemas Operativos Procesos e Hilos 27 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Creación de un proceso
Ejecución de un programa
Finalización de un proceso
Espera por la finalización de un proceso
Espera por la finalización de un proceso
Servicio POSIX
Prototipo
pid_t wait(int *status);
pid_t waitpid(pid_t pid, int *status, int options);
Descripción
o Permiten que un proceso espere por la finalización de un
proceso hijo y obtenga información sobre su estado de
terminación en status
Devuelve
El identificador del proceso hijo cuya ejecución finalizó
⇒ ¿Cómo ejecuta una orden la shell?
Sistemas Operativos Procesos e Hilos 28 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Creación de un proceso
Ejecución de un programa
Finalización de un proceso
Espera por la finalización de un proceso
Espera por la finalización de un proceso
Ejemplo 1/2
#include <sys/types.h>
#include <sys/wait.h>
int main(void)
{
pid_t id;
int estado;
id = fork();
if (id == -1) {
perror(”Error en el fork");
exit(-1);
}
Sistemas Operativos Procesos e Hilos 29 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Creación de un proceso
Ejecución de un programa
Finalización de un proceso
Espera por la finalización de un proceso
Espera por la finalización de un proceso hijo
Ejemplo 2/2
if (id == 0) {
printf("Soy el hijo\n");
sleep(5);
printf("Hijo: despierta y finaliza\n");
exit(0);
} else {
printf("Soy el padre y espero ... \n");
wait(&estado);
printf("Padre: el hijo terminó con estado = %\n", estado);
exit(0);
}
} /* Fin de main */
Sistemas Operativos Procesos e Hilos 30 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Objetivo, concepto y características
Implementación y programación
Hilos vs. procesos
Ejemplo de programación con hilos
Hilos
Objetivo
Compartir recursos entre procesos cooperantes de forma cómoda
Concepto
Hilos = proceso ligero = threads = lightweight process (LWP)
= Unidad fundamental de uso del procesador.
Básicamente se compone de un CP, una serie de registros y
un área de pila
Un hilo pertenece a otra entidad conocida como tarea (task),
y sólo a una.
El código, los datos y los recursos son propiedad de la tarea a
la que pertenece el hilo.
Sistemas Operativos Procesos e Hilos 31 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Objetivo, concepto y características
Implementación y programación
Hilos vs. procesos
Ejemplo de programación con hilos
Hilos
Características
Cada hilo comparte con los otros hilos cooperantes: código,
datos y recursos del SO
Una tarea sin hilos no tiene capacidad de ejecución
Los threads son muy adecuados para sistemas distribuidos y
sistemas multiprocesador
Un proceso tradicional (proceso pesado) se compone de una
tarea con un hilo de ejecución
TareaProceso P
Procesos ligerosProceso clásico = proceso pesado
TareaProceso P
Procesos ligerosProceso clásico = proceso pesado
Sistemas Operativos Procesos e Hilos 32 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Objetivo, concepto y características
Implementación y programación
Hilos vs. procesos
Ejemplo de programación con hilos
Hilos
Implementación y programación
Los hilos pueden ser implementados en espacio de usuario o
soportados por el núcleo como llamadas al sistema
La programación con hilos debe hacerse cuidadosamente;
pueden producirse errores de sincronización
La mayoría de los SS.OO. modernos soportan threads (OS/2,
Mach, W2K, Chorus, Linux, etc.)
¿Cómo programar con hilos?: Bibliotecas estándar DCE
Threads, POSIX Threads, Sun threads, etc.
Sistemas Operativos Procesos e Hilos 33 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Objetivo, concepto y características
Implementación y programación
Hilos vs. procesos
Ejemplo de programación con hilos
Hilos vs. procesos
Los hilos se crean y se destruyen más rápidamente que los
procesos
El tiempo de conmutación entre hilos de la misma tarea es
más rápida que la conmutación entre procesos
Todos los hilos de una tarea comparten memoria ⇒ Menor
sobrecarga de comunicaciones
Un proceso tradicional (proceso pesado) se compone de una
tarea con un hilo de ejecución
Sistemas Operativos Procesos e Hilos 34 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
Objetivo, concepto y características
Implementación y programación
Hilos vs. procesos
Ejemplo de programación con hilos
Ejemplo de programación con hilos
#include <pthread.h>
void * Hilo (void *arg) {
printf(" %s", "Soy el hilo ->");
printf(" %d\n", arg);
pthread_exit(0);
} /* Fin de Hilo */
main()
{
pthread_t hilo1, hilo2;
int i = 1;
pthread_create(&hilo1, NULL, Hilo, &i);
i++;
pthread_create(&hilo2, NULL, Hilo, &i);
sleep(30);
printf("Finaliza el hilo principal\n");
}
Sistemas Operativos Procesos e Hilos 35 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
¿Por qué es necesario?
Sincronización con semáforos
Sincronización de la ejecución de un proceso o hilo
Con frecuencia los procesos deben coordinarse entre si porque
cooperan para lograr un fin o compiten por algún recurso.
Razones para sincronizar la ejecución de los procesos
Es necesario compartir recursos en exclusión mútua.
Un proceso debe esperar hasta que otro le envíe la información
que necesita para continuar (detener su ejecución).
Varios procesos quieren escribir a la vez en la misma posición
de memoria (condiciones de carrera).
Un proceso no puede detener por si mismo su ejecución. Tampoco
puede alterar la ejecución de otro. Es necesaria la intervención del
núcleo.
Sistemas Operativos Procesos e Hilos 36 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
¿Por qué es necesario?
Sincronización con semáforos
Mecanismo de sincronización con semáforos
Los semáforos son objetos proporcionados por el núcleo y se
comparten por todos los procesos participantes en la sincronización.
Operaciones sobre los semáforos.
Operación P(semaforo):
Si el semáforo tiene valor positivo, se decrementa en una
unidad.
Si el semáforo es cero, el proceso que invoca la llamada
queda bloqueado en una lista de espera.
Operación V(semaforo):
Si el semáforo no tiene procesos bloqueados a la espera, se
incrementa en una unidad.
Si el semáforo tiene procesos bloqueados, se despierta al
primero de ellos.
Sistemas Operativos Procesos e Hilos 37 / 39
Programa
Procesos
Servicios POSIX para gestión de procesos
Hilos
Sincronización de Procesos/Hilos
¿Por qué es necesario?
Sincronización con semáforos
Solución a algunos problemas típicos con semáforos
Sección crítica
(condiciones de carrera)
P1
...
P(S1);
a++;
V(S1);
...
P2
...
P(S1);
a++;
V(S1);
...
Productor-Consumidor
Básico
Pproductor
...
datos=crear();
V(S1);
...
Pconsumidor
...
P(S1);
consumir(datos);
...
¿Afecta el valor al que estén inicializados los semáforos?
Sistemas Operativos Procesos e Hilos 38 / 39
Referencias bibliográficas I
[Sánchez, 2005] S. Sánchez Prieto.
Sistemas Operativos.
Servicio de Publicaciones de la UA, 2005.
[Márquez, 2004] Francisco M. Márquez.
UNIX. Programación Avanzada.
Ed. Ra-Ma, 2004.
[Tanenbaum, 2009] A. Tanenbaum.
Sistemas Operativos Modernos.
Ed. Pearson Education, 2009.
[Stallings, 1999] W. Stallings.
Organización y arquitectura de Computadores.
Ed. Prentice Hall, 1999.
Sistemas Operativos Procesos e Hilos 39 / 39
	Programa
	Concepto de programa
	Fases de desarrollo de un programa
	Formato de un ejecutable
	Procesos
	Concepto y características
	Bloque de control de proceso
	Estados de un proceso
	Mapa de memoria de un proceso
	Servicios POSIX para gestión de procesos
	Creación de un proceso
	Ejecución de un programa
	Finalización de un proceso
	Espera por la finalización de un proceso
	Hilos
	Objetivo, concepto y características
	Implementación y programación
	Hilos vs. procesos
	Ejemplo de programación con hilos
	Sincronización de Procesos/Hilos
	Motivos
	Sincronización con semáforos
	Apéndice
Sistemas Operativos/ssoo/tema 3 ssoo/test3/1.jpg
Sistemas Operativos/ssoo/tema 3 ssoo/test3/2.jpg
Sistemas Operativos/ssoo/tema 3 ssoo/test3/3.jpg
Sistemas Operativos/ssoo/tema 3 ssoo/test3/4.jpg
Sistemas Operativos/ssoo/tema 3 ssoo/test3/5.jpg
Sistemas Operativos/ssoo/tema 3 ssoo/test3/Pantallazo.png
Sistemas Operativos/ssoo/Tema 4 ssoo/ApuntesTema4.txt.Concepto de planificacion (I)
- El objetivo es aumentar el rendimiento y maximizar el uso de la CPU.
.Scheduler y dispatcher
- El Scheduler se encarga de elegir el siguiente proceso.
- El Dispatcher conmuta los trabajos, se encarga de el intercambio de control de ejecucion. (Interrupciones, etc.).
- Esto es frecuente por lo que es necesario que se acelere este proceso, gracias al hardware el Dispatcher hace las operaciones mas rapido.
- El Dispatcher guarda la forma de acceder a las diferentes regiones de memoria de un proceso.
- Hay llamadas bloqueantes(Espera de un recurso, espera por un semaforo) y no bloqueantes(fork etc.).
- Cuando hay una interrupcion el dispatcher puede dar paso al proceso interrumpido, por ejemplo al hacer un fork se crea un hijo pero el padre se sigue ejecutando.
- Hay mas planificadores que el scheduler(Este es a corto plazo).
- A largo plazo controla el grado de multiprogramacion ya que se encarga de cargar los procesos en memoria, actualmente nosotros somos los que cargamos los procesos.
- Planificacion a corto plazo (Scheduler) de los procesos que hay en la cola de preparados decide cual se tiene que ejecutar. Si no hay ninguno en cola se ejecuta un proceso null, que no hace nada que consuma recursos, solo espera a que llegue ottro proceso.
- Planificador a medio plazo, se encarga de administrar la solicitud de memoria dinamica cuando se supera la memoria que esta disponible fisicamente. De memoria a disco swapout al reves swapin, mete o saca procesos. Cuando la memoria llega al limite suele quitar bloqueado o los que mas CPU hayan usado recientemente.
- La desalojacion es temporal. Y tendra que hacer un swapin para volver a la ejecucion. Los candidatos son los que estan en listo para ejecutarse.
- Con el swapin y swapout puede producir vapuleos que es el continuo swapin y swapout al mismo proceso. 
.Criterios de evaluacion
- En que nos basamos para decidir la bondad de un planificador, nos basaremos en una serie de objetivos.
- Criterios de trato justo y equidad, todos los procesos tienen que llegar a ejecutarse en algun momento en la CPU. Ademas todos los procesos deben tener las mismas oportunidades de ejecutarse.
- El uso del procesador queremos que sea alto, osea que este el mayor tiempo posible ejecutandose un proceso en la CPU.
- El grado de sobrecarga, queremos que el planificador use el minimo de recursos posibles.
- Rendimiento (througput) numero de trabajos completados por unidad de tiempo. Este criterio no es muy fiable, pero a veces se tiene en cuenta.
- Tiempo de estancia (o de retorno), es el tiempo desde que se lanza un proceso hasta que termina, teniendo en cuenta las colas etc.
- Tiempo de espera, es el tiempo de espera en CUALQUIER cola y el tiempo de espera por recursos tambien. Que este bloqueado o listo etc.
- Tiempo de respuesta, desde que se realiza una peticion hasta que se obtiene una respuesta.
- En los sistemas interactivos se valora mas que los tiempos de esperas sean bajos, para que el usuario se sienta atendido.
.Algoritmos de planificacion
- Algoritmo sin requisa, el proceso se segui ejecutando hasta que finalice o hasta que se haga una entrada o salida.
	Entre ellos: · FIFO
		 · Algoritmos con prioridad sin requisa:
				- SJF
							 
- Los algoritmos con requisa intentan evitar el monopolio de uso de la CPU.
- Entre ellos estan: · Algoritmos con prioridad y con requisa: 
				- SJF con requisa
		 · Round robin
		 · Colas multinivel
		 · Colas multinivel realimentadas
.Algoritmos de planificacion (FIFO)
- FIFO: First In First Out.
- La cola de listos se maneja como una cola FIFO
- Ventajas: Facil de programar.
- Desventajas: como es sin requisa puede haber monopolio. Un proceso mal programado entra en bucle infinito y acapara toda la CPU.
- Dependiendo del tipo de proceso que llegue este algoritmo funcionara mejor o peor.
- Efecto convoy: como se ejecuta con estas caracteristicas sucede que los procesos interactivos (alto uso de entrada y salida) se ven perjudicados por los de alto uso de CPU. Por lo que no se hace uso optimo de los recursos de entrada y salida.
- Diagramas de Gant, es un esquema temporal de la gesiton de los procesos.
	No representamos la ejecucion del dispatcher.
	Tiempo medio de estancia, se suman las u.t en las que se ha cambiado de proceso y se divide entre el numero de trabajos.
	 _______________________________________________________________
	|_____________T1________________________|__ T2___|_____T3_______|
	0					12 15		21
	
	t = (12+15+21)/3 = 16 u.t.
	 ______________________________________________________
	|___T2___|_____T3_______|_____________T1_______________|
0	 3		9			 21
	t =(3+9+21)/3 = 11 u.t.
.Algoritmo con prioridades
- Se suelen basar las prioridades en recursos internos.
- Los procesos pueden morir de inanicion, es decir no pueda ejecutarse.
.SJF
- Es un algoritmo sin requisa.
- El primero el mas corto.
- Se le asigna la CPU cuya duracion de la siguiente rafaga sea mas corta.
- El inconveniente es que un proceso no se sabe cual es la duracion de la siguente rafaga, solo se puede predecir en funcion de la historia pasada.
- Un proceso de rafagas cortas en el futuro sigue siendo de rafagas cortas.
- Sigue siendo sin requisa por lo que sigue habiendo monopolio.
- No existe efecto convoy y se minimizan los tiempos de respuesta.
- Para predecir se usa una formula (Mirar diapositiva)
- Se predice la duracion de la siguiente rafaga segun la rafaga actual.
- Alfa se toma como 1/2 normalmente.
.Planificacion con requisa
- La requisa consiste en, si llega un proceso que la duracion de la siguiente rafaga es mas corta que lo que le queda al proceso actual, se le da prioridad.
.Round-robin
- Limitar el uso de la CPU por el proceso que se esta ejecutando a un maximo que se da por la interrupcion de reloj (Quantum) provoca una interrupcion que se aprovecha para desalojar el proceso.
- Pretende repartir el tiempo de CPU entre todos los procesos.
- Se maneja la cola de listos como circular, se asigna la CPU al primero y cuando termine el Quantum se pone al final.
- Si el proceso no ocupa todo el quantum desaloja voluntariamente la CPU.
.Colas multinivel
- Los procesos se clasifican en colas por orden de prioridad.
- Hay un algoritmo que decide que cola se ejecutara.
.Colas multinivel realimentada
- Es igual que el multinivel, pero existe un algoritmo para aumentar y disminuir la prioridad de las colas.
- Se suele añadir una cola con la prioridad mas alta para tareas del sistema la cual no puede variar la prioridad.
- Normalmente los hilos se colocan en la cola de mayor prioridad.
- Los procesos tienen que hacercarse al Quantum de la cola lo maximo posible, si el proceso cede la ejecucion demasiado pronto se le sube a una cola de mayor prioridad, si pasa lo contrario y sobrepasa el Quantum de la cola se le baja a una cola de menor prioridad.
- Se priorizan los procesos interactivos.
- Si el cociente (uso de CPU)/(Uso E/S) es bajo es candidato a ser ascendido por ser mas interactivo.
.Planificacion en W2K(Generalidades)
- Windows trata de beneficiar las acciones interactivas.
- Lo que habra en la cola de listos seran hilos que son los mas interactivos.
- Se ejecuta lo que este en la cola de listos.
- (Los numero 16 - 31 y 1 - 15 son numeros de cola con diferentes Quantum cada uno, a mayor numero mas prioridad, en UNIX es al reves).
.Quantum
- Se habla de unidades logicas (u.l.)
- Un tick es una interrupcion de reloj, el Quantum de mide en una cantidad de tick. En cada tick de reloj se resta 3 u.l. al Quantum.
- La version Professional tiene que ser mas interactivo pero tiene menos rendimiento que la version servidor.
.Ejecucion del planificador
- Finalizacion de Quantum, cesion involuntaria.
- El hilo pasa a espera, cesion voluntaria.
- El hilo finaliza la ejecucion, cesion voluntaria.
.Ajuste de prioridad
- Decay -> offset (-)
- Boost -> offset (+)
.Planificacion en UNIX
- Tiene round-robin.
- Beneficia las tareas interactivas. O que tienen poco uso de CPU.
- Aqui hablaremos de procesos no de hilos.
- Tiene 32 colas, la prioridad mas alta en valor no es la mas alta. Menos numero mayor prioridad. Prioridad 30 es mas prioritario que 100.
- Los procesos tienen varias prioridades, se divide la prioridad entre cuatro y se asigna a una cola. 0/4 cola 0, 3/4 cola 0, 4/4 cola 1...
	Dentro de las colas no hay prioridad va por round-robin.
- Se ejecuta el proceso que este en la primera cola y en la primera posicion.
- Se requisa un proceso por expulsion si llega uno con prioridad mayor.(Cesion involuntaria)
- Cuando expira el quantum tambien se produce cesionm involuntaria.
.Colas
- Proc es el equivalente a la task_struct.
- Colas con round-robin de prioridades dinamicas.
.Calculo de prioridades
- Cuanto mas tiempo se ejecuta un proceso va aumentando su valor de prioridad, lo que disminuye su prioridad.
- 
Sistemas Operativos/ssoo/Tema 4 ssoo/EjerciciosPlanificacion.pdf
Ejercicio 1 
El algoritmo de planificación de un sistema operativo es SJF. Considérese la siguiente 
tabla en la que se representan cinco trabajos diferentes así como sus duraciones 
respectivas: 
Trabajo T0 T1 T2 T3 T4 
t0 0 2 5 16 18
CPU 12 6 9 5 2
A partir de esta tabla, representar el estado de cada trabajo (listo, ejecución) en cada 
instante de tiempo, calculando los tiempos medios de estancia de los trabajos. 
Considere el caso a) algoritmo SJF sin requisa y el caso b) algoritmo SJF sin requisa. 
El tiempo invertido en la planificación y el cambio de contexto es despreciable. 
T0
T1 
T2
T3 
T4
CPU 
Ejercicio 2 
Considérese la siguiente tabla en la que se representan 3 procesos planificados según 
FIFO (FCFS) : 
Trabajo P0 P1 P2 
t0 0 2 5
ráfaga CPU 7 1 1 
Operación E/S 4 2 2 
Cada trabajo requiere 3 ráfagas de CPU y 2 de E/S para su finalización. Todas las 
operaciones de E/S se realizan sobre el mismo dispositivo. Las solicitudes de entradas 
salida también se planifican según el algoritmo FIFO. 
a) Representar el estado de cada trabajo (Listo, Ejecución y Bloqueado) en cada instante
de tiempo, calculando los tiempos medios de estancia de los trabajos y el porcentaje de 
utilización de la CPU y del dispositivo de E/S. Considérese que el tiempo invertido en 
la planificación y el cambio de contexto es despreciable. 
P0
P1 
P2
CPU 
E/S 
b) Realizar el mismo estudio pero considerando que cada proceso trabaja sobre un
dispositivo de E/S distinto. 
P0
P1 
P2
CPU 
c) Realizar de nuevo el mismo estudio pero considerando que el computador cuenta con
2 CPUs y que cada proceso trabaja sobre un dispositivo de E/S distinto. 
P0
P1 
P2
CPU0
CPU1
E/S0 
E/S1 
E/S2 
E/S0 
E/S1 
E/S2 
Solución ejercicio 1 (sin requisa)
t = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
T0
T1
T2
T3
T4
Uso CPU
Leyenda:
Ejecución
Listo
t estacia medio = (12 + 16 + 29 + 9 + 2) / 5 = 13,6 u.t.
% uso CPU = 34 / 34 = 100%
Solución ejercicio 1 (con requisa)
t = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
T0 2/12
T1
T2
T3 1/5
T4
Uso CPU T3
Leyenda:
Ejecución
Listo
t estacia medio = (34 + 6 + 12 + 8 + 2) / 5 = 12,4 u.t.
% uso CPU = 34 / 34 = 100%
T0 T1 T4 T3 T2
T0T4T0 T1 T2 T3
Solución ejercicio 2.a)
t = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
P0
P1 (1) (1) (1) (1) (1) (1)
P2 (1) (1) (1) (1) (1) (1) (1) (1)
Uso CPU P1 P2 P1 P2 P0 P1
Uso E/S
Leyenda:
Ejecución
Listo
Bloqueado (1) El proceso permanece bloqueado hasta que el dispositivo de E/S está disponible.
t estacia medio = (29 + (30 - 2) + (31 - 5)) / 3 = 27,67 u.t.
% uso CPU = 27 / 31 = 87,1%
% uso E/S = 16 / 31 = 51,61%
Solución ejercicio 2.b)
t = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
P0
P1
P2
Uso CPU P1 P2 P1 P2 P1 P2
Uso E/S0
Uso E/S1
Uso E/S2
Leyenda:
Ejecución
Listo
Bloqueado
t estacia medio = (29 + (20 - 2) + (22 - 5)) / 3 = 21,33 u.t.
% uso CPU = 27 / 29 = 93,1%
% uso E/S0 = 8 / 29 = 27,59%
% uso E/S1 = 4 / 29 = 13,79%
% uso E/S2 = 4 / 29 = 13,79%
P2
P0 P0 P0
P0 P0 P0
P0 P1 P2 P0 P1
P0 P0
P2
P1
P2
P1
Solución ejercicio 2.c)
t = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
P0
P1
P2
Uso CPU0
Uso CPU1 P1 P2 P1 P2 P1 P2
Uso E/S0
Uso E/S1
Uso E/S2
Leyenda:
Ejecución
Listo
Bloqueado
t estacia medio = (29 + (10 - 2) + (12 - 5)) / 3 = 14,67 u.t.
% uso CPU0 = 21 / 29 = 72,41%
% uso CPU1 = 6 / 29 = 20,69%
% uso
E/S0 = 8 / 29 = 27,59%
% uso E/S1 = 4 / 29 = 13,79%
% uso E/S2 = 4 / 29 = 13,79%
P0
P0 P0
P0 P0
P2
P1
P2
P1
	EjerciciosPlanificacion
	SolEjerciciosPlanificacion1
	SolEjerciciosPlanificacion2
Sistemas Operativos/ssoo/Tema 4 ssoo/EjPlanifSem.pdf
 
 1 
Un sistema operativo tiene una planificación basada en prioridades dinámicas (sin requisa), 15 es la 
máxima y 0 la mínima, con las siguientes características: 
§ Existe una cola para cada nivel de prioridad. 
§ Dentro de cada cola se utiliza planificación round-robin con q = 3 u.t. 
§ Los hilos heredan, como prioridad inicial, la prioridad base de la tarea a la que pertenecen. 
§ La prioridad base de la tarea T1 es 1, la de la tarea T2 es 2 y la de la tarea T3 es 3. 
§ Cuando se agota un quantum, se resta 3 a la prioridad actual y el proceso se coloca al final de la 
cola de su nivel de prioridad. 
§ Cuando se pasa del estado bloqueado al de preparado, se suma 2 a la prioridad actual. 
§ Siempre que un hilo obtenga la CPU, se reinicia su quantum. 
§ Se supone que las tareas del sistema consumen 0 u.t. de CPU. 
A este sistema llegan 3 tareas con el siguiente código: 
Tarea T1 Tarea T2 Tarea T3 
Hilo 1 Hilo 2 Hilo a Hilo b Hilo α 
ráfaga_cpu(1); 
leer_E/S(4); 
P(smf1); 
ráfaga_cpu(7); 
V(smf1); 
ráfaga_cpu(1); 
P(smf2); 
ráfaga_cpu(2); 
P(smf3); 
ráfaga_cpu(2); 
leer_E/S(2); 
ráfaga_cpu(1); 
ráfaga_cpu(2); 
leer_E/S(2); 
P(smf2); 
ráfaga_cpu(2); 
P(smf3); 
ráfaga_cpu(2); 
V(smf4); 
ráfaga_cpu(2); 
P(smf4); 
ráfaga_cpu(3); 
V(smf3); 
ráfaga_cpu(1); 
ráfaga_cpu(1); 
leer_E/S(4); 
P(smf4); 
ráfaga_cpu(2); 
V(smf2); 
ráfaga_cpu(2); 
 
Se supone que: 
§ En el instante t = 0, llegan los hilos: Hilo 1, Hilo a e Hilo α. El resto de los hilos llegan en el 
instante t = 1. 
§ La función ráfaga_cpu(n) indica una ráfaga de CPU de n unidades de tiempo. 
§ La función leer_E/S(n) indica que el dispositivo de E/S se va a usar n unidades de tiempo. 
§ El dispositivo de E/S es compartido y el manejador gestiona una cola FIFO de peticiones. 
§ Los semáforos son bloqueantes y están iniciados a 1. 
§ Las operaciones P y V consumen 1 u.t. de CPU. 
§ Los semáforos disponen de una cola FIFO en la que permanecen los trabajos, hasta que una 
operación V los despierte. 
§ Suponga que las operaciones P o V ocurren antes que la finalización de un quantum. 
Sabiendo que los hilos están soportados por el núcleo del sistema operativo: 
1. Dibuje el diagrama de ocupación de la CPU, indicando la prioridad de los hilos en cada momento 
y el estado de los semáforos implicados. 
2. Indique el tiempo de retorno, para cada hilo. El tiempo medio de retorno, el porcentaje de uso de 
CPU y del dispositivo de E/S. 
3. ¿Funciona el algoritmo de planificación correctamente? ¿se podría modificar el algoritmo para 
mejorar la eficiencia de uso de CPU? 
 
 2 
 
Apellidos, Nombre: ________________________________________________________ 
 
 
 
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
sm
f1
sm
f2
sm
f3
sm
f4
T1
H
ilo
 1
P
rio
rid
ad
H
ilo
 2
P
rio
rid
ad
T2
H
ilo
 a
P
rio
rid
ad
H
ilo
 b
P
rio
rid
ad
T3
H
ilo
 α
P
rio
rid
ad
U
so
 C
P
U
U
so
 d
is
p.
 E
/S
U
til
ic
e 
la
 s
ig
ui
en
te
 le
ye
nd
a 
pa
ra
 re
al
iz
ar
 la
 re
pr
es
en
ta
ci
ón
 g
rá
fic
a:
H
ilo
 e
n 
ej
ec
uc
ió
n
H
ilo
 p
re
pa
ra
do
H
ilo
 b
lo
qu
ea
do
 
 3 
SOLUCIÓN EJERCICIO 1: 
 
 
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
sm
f1
1
0
1
sm
f2
1
0
1
0
sm
f3
1
0
1
0
sm
f4
1
0
1
0
T1
H
ilo
 1
1/
1
P
V
P
rio
rid
ad
1
3
0
0
H
ilo
 2
1/
1
P
sm
f2
P
P
1/
1
P
rio
rid
ad
1
3
0
2
T2
H
ilo
 a
P
P
V
P
rio
rid
ad
2
4
1
0
H
ilo
 b
P
V
1/
1
P
rio
rid
ad
2
0
0
T3
H
ilo
 α
P
sm
f4
P
V
P
rio
rid
ad
3
5
7
4
U
so
 C
P
U
H
α
H
α
H
1
H
a
H
2
U
so
 E
/S
H
ilo
 e
n 
ej
ec
uc
ió
n
H
ilo
 p
re
pa
ra
do
H
ilo
 b
lo
qu
ea
do
H
2
H
a
2/
2
2/
2
E
/S7/
7
H
1
H
b
H
2
H
1
2/
2
2/
2
2/
2
H
2
H
a
H
a
H
b
H
α
H
1
5/
7
E
/S
E
/S
E
/S
2/
7
2/
2
H
a
H
1
H
b
H
α
H
2
3/
3
2/
2
2/
2
 
 4 
Tiempos de retorno 
Hilo 1 43 u.t. 
Hilo 2 44 – 1 = 43 u.t. 
Hilo a 23 u.t. 
Hilo b 37 – 1 = 36 u.t. 
Hilo α 29 u.t. 
Tiempo medio de retorno: 34,8 u.t. 
 
% Uso CPU = 44 / 44 = 100 % % Uso E/S = 12 / 44 = 27,27 % 
 
Sistemas Operativos/ssoo/Tema 4 ssoo/ejPlaniWindows.pdf
Ejercicio de la Parte IV
Se pretende diseñar el planificador de procesador para el nuevo sistema operativo VenanciOS.
Para ello se ha pensado en un algoritmo expulsivo con prioridades dinámicas comprendidas
entre 0 y 31, en las que los números bajos indican prioridad baja y lo altos prioridad alta.
Los procesos parten siempre de una prioridad fija de valor 15. Si se agota su quantum, su
prioridad disminuye en una unidad (como mı́nimo hasta valor 0) y si el proceso no lo agota
y es expulsado, se mantiene con la misma prioridad. Si el proceso se duerme a la espera de
un recurso, al despertarse incrementa su prioridad (boosting), dependiendo del tipo de recurso,
acorde con la tabla siguiente:
Recurso Incremento de prioridad
R1 1
R2 2
R3 3
R4 4
Caracteŕısticas de la planificación:
El incremento de prioridad se aplica a la prioridad con la que el proceso se durmió.
Si dos o más procesos se bloquean en el mismo recurso, éstos serán atendidos en orden
FIFO.
El sistema utiliza un valor de quantum de 2 unidades de tiempo.
Un proceso que pasa al estado de listo después de una espera, se encola al final de la cola
correspondiente a su prioridad.
Un proceso que agota su quantum, se encola al final de la cola correspondiente a su prio-
ridad.
Un proceso que es requisado por otro de mayor prioridad es encolado a la cabeza de la
cola correspondiente a su prioridad.
Cuando un proceso requisado se reanuda, se le vuelve a asignar un quantum completo.
La tabla siguiente muestra las ráfagas de CPU de los distintos trabajos aśı como el tiempo
de acceso a cada dispositivo:
Proceso CPU E/S CPU E/S CPU
P1 5 4R4 3 5R1 1
P2 1 6R2 7 14R2 1
P3 6 7R2 5 10R2 1
P4 1 12R1 3 6R1 3
Se debe suponer que todos los trabajos llegan en el instante de tiempo 0, en el orden P1, P2,
P3 y P4.
Se pide:
Dibuje en la gráfica adjunta qué trabajo se ejecuta en cada momento, aśı como su prioridad.
Muestre en la misma gráfica por qué recurso espera cada proceso en cada instante.
¿Cuál es el primer instante de tiempo en que se desencadena por primera vez los siguientes
escenarios?
• Finalización del quantum.
Examen de Arquitectura de Computadores Enero 2012
• Requisa después de una E/S.
• Boosting.
• Decremento de prioridad.
• Espera después de una E/S.
2
Sistemas Operativos/ssoo/Tema 4 ssoo/examen_extraordinario.pdf
Examen de Sistemas Operativos
Grados de Ingenieŕıa en Informática e
Ingenieŕıa de Computadores
16 de mayo de 2013
Normas
No se puede utilizar ningún tipo de documentación durante todo el examen.
Este ejercicio consta de dos partes independientes:
• Test de evaluación continua de la unidad 4:
◦ 10 preguntas tipo test (+1/respuesta acertada).
◦ Esta parte supondrá un 7,5 % de la calificación de la asignatura.
◦ Cada pregunta no contestada no puntúa.
◦ Se dispondrá de 20 minutos para esta parte.
◦ Se contestará a esta parte en la plantilla de respuestas incluida en este cuadernillo.
Sólo se entregará dicha plantilla de respuestas, que debe ser por lo tanto arrancada
del cuadernillo. No olvidar consignar en la plantilla el nombre, apellidos y DNI
del alumno.
• Ejercicio práctico de la evaluación continua:
◦ Esta parte supondrá un 40 % de la calificación de la asignatura.
◦ Cada uno de los dos ejercicios tiene el mismo valor.
◦ Se dispondrá de 2 horas para realizar este examen.
◦ Se contestará a cada problema por
Entonces, ¿te gustó este material?
Ayude a animar a otros estudiantes a mejorar el contenido
¿Te gustó este material? ¡Compartir! 🧡