Ing.

Emilio Palomino Olivera

 El proceso se define como un programa en
ejecución.
 De una forma un poco mas precisa, como la unidad
de procesamiento gestionada por el SOp.
 El Sop. Mantiene por cada proceso una serie de
estructuras de información que permiten identificar
las característica de éste, así como los recursos que
tiene asignados. En esta última categoría entran los
descriptores de segmentos de memoria asignados,
los descriptores de los archivos abiertos, los
descriptores de los puertos de comunicaciones, etc.
 Una parte muy importante de estas informaciones
se encuentra en el llamado Bloque de Control del
Proceso (BCP). El Sop mantiene una tabla de
procesos con todos los BCP de los procesos.
 Identificador “pid”
 Identificador “uid”
 Archivos abiertos
 Segmentos de memoria
 Temporizadores
 Señales
 Semáforos
 Puertos
 Contenido de los segmentos de memoria en
los que residen el código y los datos del
proceso . A esta información se le denomina
imagen de memoria o Core image.
 Contenido de los registros del modelo de
programación.
 Contenido del BCP.
 La secuencia de creación de procesos genera
un árbol de procesos.
 Para referirse a las relaciones entre los
procesos de la jerarquía se emplean los
términos de padre, hijo, hermano o abuelo.
Cuando el proceso A solicita al SOp. que cree
el proceso B, se dice que A es padre de B y
que B es hijo de A. bajo esta óptica, la
jerarquía de procesos puede considerarse
como un árbol genealógico.
 Grupos de procesos de cada shell.
 Familia de procesos
 Proceso hijo
 Proceso padre
 Proceso hermano
 Proceso Abuelo
 Vida de un Proceso
 Crea
 Ejecuta
 Muere o termina
 Ejecución del Proceso
 Batch o Background: No esta asociado a ningún
terminal, Toma los datos de un archivo y los deja en
otro.
 Interactivo: Esta asociado a un terminal. Coge
información del usuario y da una contestación.
 Grupo de Procesos.- el conjunto de procesos
creados a partir de un Shell puede formar un
grupo de procesos. También pueden formar un
grupo los procesos dependientes de un
terminal.
 El entorno del proceso consiste en un conjunto de variables que se le pasan al
proceso en el momento de su creación.
 El entorno esta formado por una tabla NOMBRE_VALOR que se incluye en la
pila del Proceso.
 El NOMBRE especifica el nombre de la variable.
 Y el VALOR su valor.
 Se establece:
 Por defecto.
 Mediante mandatos del shell ( export)
 Mediante API de SO (putenv, getenv)
 Ejemplo:
PATH=/usr/bin:/home/pepe/bin
TERM=vt100
HOME=/home/pepe
PWD=/home/pepe/libros/primero
PATH.- indica la lista de directorios en los que el SOp busca los programas
ejecutables, TERM.- el tipo de terminal, HOME.- el directorio inicial asociado
al usuario y el PWD.- el directorio de trabajo actual.
 Facilita la programación, dividiendo los
programas en procesos (modularidad).
 Permite prestar un buen servicio, atendiendo a
varios usuarios de forma eficiente, interactiva y
simultanea.
 Aprovecha los tiempos que los procesos pasan
esperando a que se completen sus operaciones
de E/S.
 Aumenta el uso de la CPU, al aprovechar los
espacios de tiempo que los procesos están
bloqueados.
 A mayor Grado de multiprogramación se
tiene mayores necesidades de memoria.
 En un sistema sin memoria virtual los
procesos activos han de residir totalmente en
memoria principal.
 El grado de multiprogramación viene
limitado por el tamaño de los procesos y por
la memoria disponible.
 En los sistemas con memoria virtual es mas complejo,
puesto que los procesos solo tienen en memoria principal
su conjunto residente, lo que hace que quepan mas
procesos.
 Sin embargo al aumentar el número de procesos
disminuye el conjunto residente de cada uno.
 Cuando el conjunto residente de un proceso se hace
menor de un determinado valor ya no representa
adecuadamente al futuro conjunto de trabajo del proceso,
lo que tiene como consecuencia que se produzcan muchos
fallos de pagina. Cada fallo de pagina consume tiempo de
procesador, por que el Sop ha de tratar el fallo, y tiempo
de E/S, puesto que hay que hacer una migración de
paginas.
 Cuando la memoria principal disponible es pequeña, se
llega a la situación de hiperpaginación (trashing), antes
de alcanzar una cota alta de utilización del procesador.
Para aumentar el rendimiento de un sistema que este
en esta situación es necesario añadir mas memoria
principal.
 Cuando la memoria es grande se llega a saturar el
procesador con menos procesos de los que caben en
memoria. En este caso se puede aumentar el
rendimiento del sistema manteniendo la memoria pero
aumentando la potencia del procesador o añadiendo
otro procesador.
 El Proceso es la Unidad de procesamiento
gestionada por el Sop. Para realizar este
cometido el proceso tiene asociado una serie de
elementos de información organizados en tres
grupos:
 Estado del procesador: contenido de los registros del
modelo de programación.
 Imagen de memoria del proceso: contenido de los
segmentos de memoria en los que reside el código y
los datos del proceso.
 Contenido del bloque de control del proceso BCP.
 Esta formado por el contenido de todos sus registros:
 Registros generales, registros específicos de coma float
también se incluyen aquí.
 Contador de programas
 Puntero de pila
 Registros de estado
 Registros especiales. RIED (Reg. Identificador de Espacio de
Direcciones)
 Cuando un proceso esta ejecutándose su estado reside en
los registros del computador.
 Cuando un proceso no ejecuta su estado reside en el BCP.
 La imagen de memoria esta formada por los
espacios de memoria que un proceso esta
autorizado a utilizar. Principales características:
 Si un proceso genera una dirección que esta fuera del
espacio de direcciones, el HW de protección deberá
detectarlo y levantar una excepción (TRAP).
 La imagen de memoria dependiendo del computador
puede esta referida a memoria virtual o física.
 Asignación de Memoria contempla la modificación de la
imagen de memoria y la asignación de marcos de memoria
es de aplicación en los sistemas con memoria virtual y se
refiere a la modificación del conjunto residente del
proceso.
 Los mecanismos de Memoria
Principal
Cmp > RegLim excepción
de violación de memoria,
Sop trate el tema.
protección de memoria
deben evitar que un
programa en ejecución Registro
Límite
Región
direccione posiciones de asignada al
Proceso Registros
memoria que no le hayan sido Valla

asignadas por el sistema

operativo. Registro
base

 Solución en máquinas sin Posición 0

memoria virtual es incluir una

pareja de registros valla
 Un proceso contiene varios tipos de información.
 Texto o código. El programa maquina que ha de ejecutar
el proceso.
 Datos. Cada programa estructura sus datos de acuerdo a
sus necesidades.
▪ Datos con valor inicial
▪ Datos sin valor inicial
▪ Datos dinámicos
 Pila. Los programas usan una estructura de pila residente
en memoria.
 El modelo tradicional usado en UNIX
contempla 3 segmentos: texto, pila y
datos.
 Observe que el segmento de texto es
de tamaño fijo ( el programa
habitualmente no se modifica) y que
los segmentos de pila y de datos
crecen en direcciones contrarias.
 Este modelo se adapta bien a los
sistemas con memoria virtual,
puesto que el espacio virtual
reservado no existe, para que
puedan crecer los segmentos de
datos y pila. Solamente se crea,
gastando recursos de disco y
memoria, cuando se asigna.
 Este modelo es mas avanzado
que la anterior, al permitir que
existan los segmentos que
desee el proceso.
 El ejemplo presenta un caso
de siete segmentos que
podrán ser de texto, de pila o
de datos.
 Es la solución mas flexible y,
por tanto, la utilizada en los
Sop modernos como Win NT y
las versiones actuales de UNIX
 La preparación del
código de un
proceso, también
llamado texto del
proceso, sigue los
siguientes pasos.
 El SOp. Mantiene una serie de tablas que describen los procesos y a los
recursos del sistema. La información asociada a cada proceso se
encuentra parcialmente en el BCP y parcialmente fuera de él.
 Cuando la información ha de ser compartida por varios procesos, no ha de
residir en el BCP, que es de acceso restringido al proceso que lo ocupa. A lo
sumo, el BCP contendrá un apuntador que permita alcanzar esa información.
 Consiste en completar todas las informaciones que lo constituyen, mas
especifico, las operaciones que debe hacer el Sop son las siguientes:
 Asignar un espacio de memoria para albergar la imagen de memoria. Sera
virtual y compuesto por varios segmentos.
 Seleccionar un BCP libre de la tabla de procesos.
 Rellenar el BCP con la información de identificación del proceso, descripción
de la memoria asignada, con los valores iniciales de los registros indicados
en el archivo objeto, etc.
 Cargar en el segmento de texto, el código mas las rutinas del sistema y en el
segmento de datos los datos iniciales contenidos en el archivo objeto.
 Crear en el segmento de pila, la pila inicial del proceso.

 Una vez completada toda la información del proceso, se puede marcar como
listo para ejecutar, de forma que el planificador, cuando lo considere oportuno,
lo seleccione para su ejecución.
 Ejecución.- El proceso esta siendo ejecutado por el
procesador, es decir, esta en fase de procesamiento y el
estado del proceso reside en los registros del procesador.
 Bloqueado.- un proceso bloqueado esta esperando a que
ocurra un evento y no puede seguir ejecutando hasta que
suceda el evento – es cuando el proceso solicita una
operación de E/S, hasta que no termina esta operación el
proceso queda bloqueado, en esta fase el estado del
proceso reside en el BCP.
 Listo.- un proceso esta listo para ejecutar cuando puede
entrar en fase de procesamiento. Dado que puede haber
varios procesos en este estado, una de las tareas del
sistema operativo será seleccionar aquel que debe pasar a
ejecución y esto lo realiza el modulo Planificador del Sop.
En esta fase el estado del proceso reside en el BCP.
 Se muestra estos 3 estados,
indicando algunas de las posibles
transiciones:
 Puede verse que hay un solo
proceso en ejecución.
 Del estado de ejecución se pasa al
estado de bloqueado al solicitar
una operación de E/S.
 También puede pasar del estado
de ejecución al estado de listo
cuando el Sop decide que ese
proceso lleva mucho tiempo en
ejecución.
 Del estado de bloqueado pasa al
estado del listo cuando se produce
el evento por el que estaba
esperando el proceso (cuando se
completa la operación de E/S
solicitada)
 Los procesos entran en el sistema porque lo solicita un
proceso de usuario o porque esta prevista su ejecución Batch.
 Es frecuente tener una lista de procesos Batch en espera para
ser ejecutados cuando se pueda. El sistema operativo ha de ir
analizando dicha lista para lanzar la ejecución de los procesos
a medida que disponga de los recursos necesarios.
 Los procesos salen del sistema cuando mueren, es decir, al
ejecutar el servicio correspondiente o al producir algún error
irrecuperable.
 El SOp. Puede suspender algunos procesos, lo que implica
retirar sus marcos de páginas, dejándolos en la zona de
intercambio. El objetivo es dejar suficiente memoria a los
procesos no suspendidos para que su conjunto residente
tenga un tamaño adecuado que evite la hiperpaginación.
 Los procesos Batch que entran en el sistema lo hacen pasando
al estado listo o al de listo suspendido.
 Hilos a nivel de usuario.
– Se usan aplicaciones o bibliotecas de hilos para
manejarse (Creación, destrucción, planificación).
– El S.O. no conoce la existencia de los hilos
– (Unix) Existe un único hilo por proceso
– Hay un paquete de hilos que corre en el espacio del
usuario
 Hilos a nivel de Kernel.
– El sistema operativo conoce la existencia de los
hilos.
– El planificador no selecciona procesos para ser
ejecutados sino hilos.
– El hilo seleccionado puede pertenecer al mismo
proceso o a un proceso diferente
 Web browser
– Un Hilo decodifica la página y la presenta en Pantalla.
– Un Hilo toma los datos de la página de Internet.
 Procesador de Texto.
– Un Hilo despliega en Pantalla la interfaz.
– Un Hilo toma los datos del Teclado.
– Un Hilo revisa la ortografía.
 Servidor Web
– Un Hilo acepta peticiones de los clientes.
– Para cada petición recibida se crea un Hilo que la atiende.
– Usa muchos Hilos para atender en paralelo a muchos
clientes.
 Un proceso ligero o thread es un
programa en ejecución que
comparte la imagen de memoria y
otras informaciones con otros
procesos ligeros
 Un proceso puede contener un solo
flujo de ejecución, como ocurre en
los procesos clásicos, o mas de un
flujo de ejecución (procesos
ligeros).
 Un proceso ligero se define como una función cuya
ejecución se puede lanzar en paralelo con otras. El
hilo de ejecución primario, o de proceso ligero
primario, corresponde a la función main
 Cada proceso ligero tiene informaciones que le
son propias y que no comparte con otros proceso
ligeros, las informaciones propias se refieren
fundamentalmente al contexto de ejecución,
pudiéndose destacar las siguientes:
 Contador de programa
 Pila
 Registros
 Estado del proceso ligero (ejecutando, listo o
bloqueado)
 Todos los proceso ligeros de un mismo proceso
comparten la información del mismo, es decir:
 Espacio de memoria
 Variables globales
 Archivos abiertos
 Procesos hijos
 Temporizadores
 Señales y semáforos
 Contabilidad
El estado del Proceso P es la combinación de los
estados de sus Hilos.

• Cuando cualquiera de los Hilos está en estado

“Ejecutando”, el estado de P será “Ejecutando”.
• Si ningún Hilo está en “Ejecutando”, y alguno
está en “Listo”, el estado de P será “Listo”.
• El estado de P es “Bloqueado” sólo si todos sus
Hilos están en estado “Bloqueado”.
 Cada proceso ligero de un proceso tiene su propio estado bloqueado, listo o en ejecución.
 El estado del proceso será la combinación de los estados de sus procesos ligeros. Ej: si tiene un proceso ligero en
ejecución, el proceso esta en ejecución.
 Los procesos ligeros permiten ejecutar una
aplicación en paralelo.
 Un programa puede dividirse en procedimientos
que se ejecutan de forma independiente, el
mecanismo de los procesos ligeros permite
lanzar simultáneamente la ejecución de todos
ellos. De esta forma se consigue que el proceso
avance mas rápidamente.
 La base del paralelismo estriba en que, mientras un
proceso ligero esta bloqueado, otro puede ejecutar.
 Permite separación de tareas. Cada tarea se puede
encapsular en un proceso ligero independiente.
 Facilita la modularidad, al dividir trabajos
complejos en tareas.
 Aumenta la velocidad de ejecución de trabajo,
puesto que aprovecha los tiempos de bloqueo de
unos procesos ligeros para ejecutar otros.
 El paralelismo que permiten los procesos ligeros
unido a que comparten memoria (utilizan variables
globales que ven todos ellos) permite la
programación concurrente.
 El objetivo es el reparto del tiempo de
procesador entre los procesos que puede
ejecutar.
 Planificador: selecciona el proceso en estado
listo y pasa a estado de ejecución.
 Activador: pone en ejecución el proceso
planificado.
 A largo plazo: añade nuevos procesos al
sistema de la lista de espera. En los que no
importa cuando se ejecuten.
 A mediano plazo: trata la suspensión de
procesos, decide que procesos pasan a
suspendido y cuales dejan de estar
suspendidos.
 A corto plazo: selecciona el proceso en
estado de listo pasando a estado de
ejecucion.
 Reparto equitativo del procesador
 Eficiencia (optimizar el uso de procesador)
 Menor tiempo de repuesta en uso interactivo
 Menor tiempo de espera en lotes (batch)
 Mayor numero de trabajos por unidad de
tiempo (batch)
 Cumplir los plazos de ejecución de un sistema
de tiempo real.
 La colas de proceso se construyen con unas cabeceras y
con unos punteros que están incluidos en los BCP.
• Planificación de sistemas de tiempo real.
• A plazo fijo: ejecuta una vez en un instante
determinado.
• Periódico: ejecuta de forma repetitiva cada ciernto
tiempo.
 El programador encierra dentro del bloque TRY el fragmento de código que quiere
proteger de la generación de excepciones. En el Bloque EXCEPT sitúa el manejador de
excepciones. En caso de generarse una excepción en el bloque TRY, el Sop transfiere el
control al bloque EXCEPT que se encargara de manejar la correspondiente excepción.
 Se invoca el servicio FORK. El Sop trata este
servicio realizando una clonación del proceso
que lo solicite. El proceso que solicita el
servicio se convierte en el proceso padre del
nuevo proceso, que es, a su vez, el proceso
hijo. El prototipo de esta función es:
 pid_t fork()
 La llamada fork() crea una copia (hijo) del
proceso que la invoca
 El hijo hereda del padre:
 Estado
 Semáforos
 Objetos de memoria
 Política de planificación, etc.
 El hijo no hereda:
 El PID
 Alarmas y temporizadores
 Operaciones de E/S asíncronas
 Definida en:
#include <sys/types.h>
pid_t fork(void);
 Valores de retorno:
 Al padre: el PID del hijo
 Al hijo: cero
 En caso de error: devuelve -1 y la variable errno
contiene el valor asociado al error
#include <sys/types.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”);
}
} /* Fin de main */
 01) #include <unistd.h>  Las lineas número (01)-(03) contienen los includes de
 (02) #include <sys/types.h> las librerías necesarias (E/S estándar, multitarea).
 (03) #include <stdio.h> ( El main (como siempre en GNU), devuelve un entero,
 04) int main() que es normalmente cero si el programa llega al final
 (05) { sin errores o un código de error si va algo mal; Luego
 (05) pid_t pid; definimos un tipo de dato para contener un pid (05) y
 (06) int i; un entero para usarlo como contador del bucle (06).
 (07) pid = fork(); Estos dos tipos, como se dijo antes, son idénticos,
 (08) if (pid == 0){ pero están ahí para mayor claridad.
 (09) for (i = 0; i < 8; i++){ En la linea (07) llamamos a la función fork, la cual
 (10) printf("-Hijo-\n"); devolverá cero al programa ejecutado en el proceso
 (11) } hijo y el pid del proceso hijo al padre; la
 (12) return(0); ( comprobación está en la linea (08). Ahora el código
 13) } de las lineas (09)-(13) se ejecutarán en el proceso
 (14) for (i = 0; i < 8; i++){ hijo, mientras que el resto (14)-(16) las ejecutará el
 (15) printf("+Padre+\n"); padre.
 (16) } Las dos partes simplemente escriben 8 veces en la
 (17) return(0); salida estándar la palabra "-Hijo-" o "+Padre+",
 (18) } dependiendo en que proceso se ejecuta, y luego
termina devolviendo 0. Esto es verdaderamente
importante, ya que sin este último "return" el
proceso hijo, una vez que el bucle termine, seguirá
ejecutando el código del padre
 El proceso hijo tiene su propio identificador(PID).
 El proceso hijo tiene una nueva descripción de la
memoria. Aunque el hijo tenga los segmentos con
el mismo contenido, no tienen por que estar en la
misma zona de memoria.
 El tiempo de ejecución del proceso hijo es igual a
cero.
 Todas la alarmas pendientes se desactiva en el
proceso hijo.
 El conjunto de señales pendientes se pone en cero.
 El valor que retorna el sistema operativo como
resultado de fork() es distinto en el hijo que el padre
(el hijo recibe un 0 y el padre el PID del hijo).
#include <sys/types.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
int main(){
pid_t pid;
pid = fork();
if(pid==-1) /* error del fork() */
printf(“Error\n”);
else if(pid==0)
printf("Soy el HIJO, Proceso %d; padre = %d \n",
getpid(), getppid());
else
printf("Soy el PADRE, Proceso %d\n", getpid());
}
// En cada ejecución del bucle crea un proceso. El proceso padre obtiene el
// identificador del hijo, que será distinto de cero y saldrá del bucle utilizando
la sentencia “break”. El proceso hijo continuará la ejecución, repitiéndose
// este proceso hasta que se llegue al final del bucle
#include <sys/types.h>
#include <stdio.h>
#include <unistd.h>
int main()
{
pid_t pid;
int i;
int n = 10;
for (i = 0; i < n; i++){
pid = fork();
if (pid != 0)
break;
}
printf("El padre del proceso %d es %d\n", getpid(), getppid());
}