Wiki de Sistemas Operativos - Contribuciones del usuario [es]

Planificación en sistemas multiprocesadores

2012-01-29T17:57:00Z

Migoligon: titulo y negrita

=5.2 Planificación en sistemas multiprocesadores=

Los sistemas multiprocesadores son aquellos que disponen de 2 o más procesadores. Hasta el momento hemos aplicado los criterios de planificación considerando un único procesador. Con más de un procesador, tenemos que decidir a qué procesador se asignan cada uno de los procesos en ejecución. Hay dos estrategias de asignación en sistemas multiprocesadores, que son:

* '''Asignación estática''': Cuando un proceso pasa a estado activo por primera vez, se le asigna un determinado procesador (el que menor carga de trabajo tenga en ese momento) al que se asocia hasta fin de ejecución. Por tanto, un proceso tiene que pasar a estado activo empleando el mismo procesador hasta fin de ejecución. Dicho de otra manera, no es posible migrar procesos de un procesador a otro incluso si hay procesadores ociosos.

* '''Asignación dinámica''': En este caso, nuestros procesos en estado preparado pueden cambiar de procesador para pasar a estado activo si resulta que el último procesador en el que se ejecutó está ocupado y existe un procesador ocioso. Este método de asignación permite la migración de procesos de un procesador a otro, llevando a cabo un balanceo de carga de procesos entre los procesadores existentes. No obstante, la migración de un proceso de un procesador a otro es costosa. Por tanto, '''siempre que sea posible''' se intentará permanecer en el mismo procesador para no incurrir en la penalización asociada a los fallos de caché que resultan de la migración de procesos.

Los planificadores de los sistemas operativos modernos aplican una ''asignación híbrida'' de manera que emplea asignación estática la mayor parte del tiempo. Sin embargo, si el número de procesos asociados a un procesador supera en N unidades al de otro, se procede a migrar procesos al procesador con menor número de procesos para balancear la carga de trabajo. Este es el caso del planificador del núcleo de Linux.

El alto coste en la migración de procesos entre procesadores se debe a la penalización asociada a los fallos en la caché. Cada procesador generalmente dispone de una pequeña memoria asociativa de acceso rápido, también conocida como caché, en la que se almacenan los datos accedidos recientemente. Si migramos un proceso de procesador se tienen que cargar de nuevo los datos en la caché del nuevo procesador, incrementando de manera considerable los tiempos de accesos a datos.

A continuación, un ejemplo de planificación en sistemas multiprocesadores con dos CPUs que emplea asignación estática:
[[Archivo:Ejemplo de multiprocesador.png]]

Fíjese que tras el instante de tiempo 1, el proceso A continúa en el CPU 1 pues el proceso B se asignó al CPU 2, que estaba ocioso en ese instante de tiempo.

Archivo:Ejemplo de multiprocesador.png

2012-01-29T17:55:30Z

Migoligon: subió una nueva versión de «Archivo:Ejemplo de multiprocesador.png»: Revertido a la versión subida el 1 nov 2011 a las 10:39 si quito lo blanco se ve demasiado pequeño y se ve peor

Archivo:Ejemplo de multiprocesador.png

2012-01-29T17:53:47Z

Migoligon: subió una nueva versión de «Archivo:Ejemplo de multiprocesador.png»: quitar todo lo blanco que sobra y hace feo.

Planificación de procesos de tiempo real

2012-01-29T17:11:26Z

Migoligon: /* Clasificación */ Darwin OS, no solo es el nombre del planificador del Mac OS si que también es un SO. (añado enlace)

== ¿Qué es un proceso de tiempo real? ==

Un proceso de tiempo real es aquel cuya actividad tiene un '''plazo de finalización'''.

== ¿Qué es un sistema operativo de tiempo real? ==

Un sistema operativo de tiempo real dispone de un planificador de procesos que tiene mecanismos para hacer lo máximo posible para garantizar que sus procesos de tiempo real cumplan los plazos de finalización que tienen establecidos.

== Clasificación ==

Podemos clasificar los procesos de tiempo real de diferentes maneras:

Segun el plazo de tiempo:
*'''Rígidos(''hard-realtime'')''' : se debe realizar en un plazo de tiempo determinado. Si no lo hace, deja de tener sentido. Si el plazo de tiempo para realizarla es superado el proceso se aborta. Ejemplo: Industriales ( sensores, activadores,...).

*'''Flexibles(''soft-realtime'')''' : es deseable que se cumpla el plazo de tiempo. Ej: Videoconferencia.(Mientras más rapido vaya mejor sera la comunicacion , pero si no , nos adaptamos a ella)

*'''Opcionales''' : conviene hacerla en el plazo de tiempo, pero si no es posible se puede posponer. Ej: actualización de una aplicacion/programa instalada en el ordenador.

Según la periodicidad:

*'''Aperiódicas''' : se deben a sucesos externos que deben ser atendidos. El sistema operativo no sabe, a priori, cuándo van a llegar ni el tiempo que va a durar. Ej: Notificaciones de errores, Sensores de emergencia en un coche, Ventiladores para refrigeración.

*'''Periódicas''' : se realizan cada cierto tiempo (actividad repetitiva). A diferencia del anterior el sistema operativo conoce a priori cuándo van a llegar y su tiempo de duración Ej: leer la temperatura de un sensor.

Podemos tener aplicaciones de tiempo real (flexibles) en sistemas operativos que no son de tiempo real (Linux, [http://darwinosx.blogspot.com/p/descarga-darwin-os.html Darwin], Windows).

== Métodos de planificación ==

Los métodos de planificación a utilizar en SSOO de tiempo real son:

*'''Planificación apropiativa con prioridad estática''': Cada proceso tiene asociado un índice de prioridad y el procesador elige aquel proceso de la lista de preparados con mayor prioridad, es el más tradicional y puede ser llevado a cabo por el procesador de un sistema que no sea de tiempo real.

*'''Planificación de tablas estáticas''': se conocen las actividades a realizar (todas periódicas) y se elabora un plan fijo de ejecución.

*'''Planificación dinámica''': Es muy parecida a la de tablas estáticas , pero también admite actividades aperiódicas. Cuando se presenta una actividad aperiódica , el planificador intenta construir un nuevo plan de ejecución que incluya a todas las actividades. Si no encuentra la solución que las englobe a todas, rechaza la actividad, que debe ser flexible u opcional. También puede retrasar alguna actividad flexible/opcional.

*'''Planificación dinámica con un mejor resultado''':Se utiliza para aplicaciones compuestas mayormente por actividades aperiódicas.El planificador intenta cumplir el plazo de todas las actividades asignandole a cada actividad una prioridad en base a sus características (las actividades fuera de plazo se abortan). Es muy similar a la anterior, la diferencia más notable es que en la anterior existe un análisis previo aceptando actividades aperiódicas y en ésta no existe tal análisis.
Es un método fácil de implementar, sin embargo, no podremos saber de antemano si una actividad cumplirá su plazo o no (sabremos que no lo cumple si es abortada, y viceversa).

El siguiente ejemplo emplea planificación apropiativa por prioridades estática con actividades periódicas y aperiódicas:

____|__PA__|_PB__|_PC__|_PD___|
Datos del _H0_|__0___|_1___|_2___|_3*n__|
problema _t__|__2___|_4___|_2___|_1____|
plazo|__3___|_5___|_7___|_3*n+2|
prioridad|__-20_|_0___|_10__|_15___|
(-20 a 19)
UNIX
< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
X = se ejecuta el código del planificador
plazo = si la actividad no ha terminado de ejecutarse tras pasar este instante de tiempo, se aborta
* = el proceso se aborta

| | | | | | | | | | | | | | | | | | | | |
PA <---|---> | | | | | | | | | | | | | | | | | |
PB | < |---|---|---* | | | | | | | | | | | | | | |
PC | | < | | |---|---> | | | | | | | | | | | | |
PD | | | < | * < |---> <---> | <---> | <---> | | | |
Planificador X X X X | X X X | X | | X | | X | | | | |
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

_____|_PA_|_PB_|_PC_|PD1ª_|PD2ª_|_PD_|
Cálculos __t__|_2__|_3__|_2__|_1__|_1__|_1__|
de tiempos __T__|_2__|_*__|_4__|_*__|_2__|_1__|
_T/t_|_1__|_*__|_2__|_*__|_2__|_1__|
|
|_> Indice de penalización

Si alguna actividad entrante tiene más prioridad que la que se está ejecutando, ésta última pasa a estado preparado y se da paso a la nueva.

Planificación de procesos de tiempo real

2012-01-29T17:00:38Z

Migoligon: /* ¿Qué es un proceso de tiempo real? */ reconstruir la frase para que no sea tan redundante

== ¿Qué es un proceso de tiempo real? ==

Un proceso de tiempo real es aquel cuya actividad tiene un '''plazo de finalización'''.

== ¿Qué es un sistema operativo de tiempo real? ==

Un sistema operativo de tiempo real dispone de un planificador de procesos que tiene mecanismos para hacer lo máximo posible para garantizar que sus procesos de tiempo real cumplan los plazos de finalización que tienen establecidos.

== Clasificación ==

Podemos clasificar los procesos de tiempo real de diferentes maneras:

Segun el plazo de tiempo:
*'''Rígidos(''hard-realtime'')''' : se debe realizar en un plazo de tiempo determinado. Si no lo hace, deja de tener sentido. Si el plazo de tiempo para realizarla es superado el proceso se aborta. Ejemplo: Industriales ( sensores, activadores,...).

*'''Flexibles(''soft-realtime'')''' : es deseable que se cumpla el plazo de tiempo. Ej: Videoconferencia.(Mientras más rapido vaya mejor sera la comunicacion , pero si no , nos adaptamos a ella)

*'''Opcionales''' : conviene hacerla en el plazo de tiempo, pero si no es posible se puede posponer. Ej: actualización de una aplicacion/programa instalada en el ordenador.

Según la periodicidad:

*'''Aperiódicas''' : se deben a sucesos externos que deben ser atendidos. El sistema operativo no sabe, a priori, cuándo van a llegar ni el tiempo que va a durar. Ej: Notificaciones de errores, Sensores de emergencia en un coche, Ventiladores para refrigeración.

*'''Periódicas''' : se realizan cada cierto tiempo (actividad repetitiva). A diferencia del anterior el sistema operativo conoce a priori cuándo van a llegar y su tiempo de duración Ej: leer la temperatura de un sensor.

Podemos tener aplicaciones de tiempo real (flexibles) en sistemas operativos que no son de tiempo real (Linux, Darwin, Windows).

== Métodos de planificación ==

Los métodos de planificación a utilizar en SSOO de tiempo real son:

*'''Planificación apropiativa con prioridad estática''': Cada proceso tiene asociado un índice de prioridad y el procesador elige aquel proceso de la lista de preparados con mayor prioridad, es el más tradicional y puede ser llevado a cabo por el procesador de un sistema que no sea de tiempo real.

*'''Planificación de tablas estáticas''': se conocen las actividades a realizar (todas periódicas) y se elabora un plan fijo de ejecución.

*'''Planificación dinámica''': Es muy parecida a la de tablas estáticas , pero también admite actividades aperiódicas. Cuando se presenta una actividad aperiódica , el planificador intenta construir un nuevo plan de ejecución que incluya a todas las actividades. Si no encuentra la solución que las englobe a todas, rechaza la actividad, que debe ser flexible u opcional. También puede retrasar alguna actividad flexible/opcional.

*'''Planificación dinámica con un mejor resultado''':Se utiliza para aplicaciones compuestas mayormente por actividades aperiódicas.El planificador intenta cumplir el plazo de todas las actividades asignandole a cada actividad una prioridad en base a sus características (las actividades fuera de plazo se abortan). Es muy similar a la anterior, la diferencia más notable es que en la anterior existe un análisis previo aceptando actividades aperiódicas y en ésta no existe tal análisis.
Es un método fácil de implementar, sin embargo, no podremos saber de antemano si una actividad cumplirá su plazo o no (sabremos que no lo cumple si es abortada, y viceversa).

El siguiente ejemplo emplea planificación apropiativa por prioridades estática con actividades periódicas y aperiódicas:

____|__PA__|_PB__|_PC__|_PD___|
Datos del _H0_|__0___|_1___|_2___|_3*n__|
problema _t__|__2___|_4___|_2___|_1____|
plazo|__3___|_5___|_7___|_3*n+2|
prioridad|__-20_|_0___|_10__|_15___|
(-20 a 19)
UNIX
< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
X = se ejecuta el código del planificador
plazo = si la actividad no ha terminado de ejecutarse tras pasar este instante de tiempo, se aborta
* = el proceso se aborta

| | | | | | | | | | | | | | | | | | | | |
PA <---|---> | | | | | | | | | | | | | | | | | |
PB | < |---|---|---* | | | | | | | | | | | | | | |
PC | | < | | |---|---> | | | | | | | | | | | | |
PD | | | < | * < |---> <---> | <---> | <---> | | | |
Planificador X X X X | X X X | X | | X | | X | | | | |
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

_____|_PA_|_PB_|_PC_|PD1ª_|PD2ª_|_PD_|
Cálculos __t__|_2__|_3__|_2__|_1__|_1__|_1__|
de tiempos __T__|_2__|_*__|_4__|_*__|_2__|_1__|
_T/t_|_1__|_*__|_2__|_*__|_2__|_1__|
|
|_> Indice de penalización

Si alguna actividad entrante tiene más prioridad que la que se está ejecutando, ésta última pasa a estado preparado y se da paso a la nueva.

Hilos

2012-01-29T15:09:40Z

Migoligon: poner titulo, crear oraciones apartir de frases sueltas, resaltar en negrita las ventajas

= 3.5 Hilos =

Un hilo es un "proceso ligero", es decir, una línea de ejecución. En general, el planificador de procesos da el mismo tratamiento a los hilos y a los procesos, pero la conmutación de hilos es menos costosa que la conmutación de procesos.

Los procesos inicialmente parten con un único hilo, aunque el sistema operativo ofrece llamadas al sistema para crear y destruir hilos. Puedo hacer uso de estas llamadas al sistema desde el propio código del programa.

Cuando se crea un hilo, se le indica qué código se quiere que ejecute. Distintos hilos, de un mismo proceso, comparten espacio de memoria.

Veamos un ejemplo diseñado para un solo procesador:

[[Archivo:Uso_del_procesador_hilos.svg]]

Con multiprocesamiento podemos ejecutar diferentes procesos a la vez. Si tenemos uno solo podemos desdoblarlo en hilos, usando técnicas de programación apoyadas en APIS (como POSIX threads).

Para aumentar su eficiencia, un programa en ejecución debe crear tantos hilos como el doble del número de procesadores del los que disponga el sistema. Por ejemplo: 4 hilos para un programa ejecutado con 2 procesadores.

Las principales ventajas del uso de hilos son:

*'''Menor penalización''' en cuanto a conmutación.

*Dos hilos de un mismo proceso pueden '''compartir memoria''' aprovechando mejor los recursos y eliminando los mecanismos de comunicación necesarios para soluciones implementadas en varios procesos.

*Con un solo procesador es posible que una línea de proceso haga uso de una llamada al sistema bloqueante. En este caso se puede llamar a otro hilo del mismo proceso en lugar de conmutar a otro proceso externo, ahorrando así tiempo de conmutación asociado a la ejecución del planificador de procesos.

= Ejemplo =

El siguiente es un código en C de ejemplo en el que se muestra la creación de dos hilos. Se hace uso de la llamada al sistema ''sleep'' que hace que el proceso pase a estado bloqueado durante N segundos. Nótese que al compartir la variable ''a'', ambos hilos modifican su valor.

<source lang="c">
#include <stdio.h>
#include <pthread.h>

int a = 10;

void *codigo_hilo1(void *arg)
{
sleep(10);
a = a - 2;
printf("Soy el hilo 1 y la variable a vale %d\n", a);
return NULL;
}

void *codigo_hilo2(void *arg)
{
sleep(5);
a++;
printf("Soy el hilo 2 y la variable a vale %d\n", a);
return NULL;
}

int main(void)
{
pthread_t hilo1, hilo2;

pthread_create(&hilo1, NULL, codigo_hilo1, NULL);
pthread_create(&hilo2, NULL, codigo_hilo2, NULL);

pthread_join(hilo1, NULL);
pthread_join(hilo2, NULL);
}
</source>

Este ejemplo se compila en un terminal escribiendo: '''gcc -lpthread archivo.c'''

Multiprogramación

2012-01-29T12:59:49Z

Migoligon: reducir tamaño de la imagen porque se veía muy grande y descuadraba la wiki

=3.1 La Multiprogramación =

La multiprogramación es una técnica de multiplexación que permite la ejecución simultánea de múltiples procesos en un único procesador. En realidad, esta técnica produce una ilusión de paralelismo, de manera que parece que todos los procesos se están ejecutando a la vez. Sin embargo, hay un único proceso ejecutándose en el procesador a la vez.

Un método para la multiprogramación es el Foreground/Background (o ejecución jerarquizada) (usado en sistemas por tandas, nunca en interactivos), en él hay un proceso prioritario (el foreground (FG)) que se ejecuta con preferencia de todos los demás, cuando este proceso solicita una operación L/E, mientras el s.o. la realiza, el proceso FG estará bloqueado por esta operación y le cede el control al proceso background 1 (BG), y si éste realiza una operación L/E, al BG2,… Cuando uno de los procesos bloqueados se desbloquea, recibe el control del procesador. Para que este método funcione de forma óptima la mejor forma es colocar los procesos ordenados de mayor a menor cantidad de operaciones L/E.

El siguiente diagrama de ejemplo representa el uso del procesador por tres procesos:

[[Archivo:Uso_del_procesador_general.svg|500px]]

Como se puede observar en el ejemplo anterior, los procesos '''alternan periodos''' en los que '''progresan''' en su actividad, cuando están asignados al procesador, con periodos de inactividad, en los que '''no progresan''' en absoluto.

Si los periodos de inactividad son los suficientemente pequeños como para que el usuario del sistema operativo no los note, que en práctica se traduce a periodos de inactividad de menos de 100ms, el efecto causado es una ilusión de paralelismo. En caso contrario dará una sensación de que se producen "saltos".

El [[planificador de procesos|planificador de procesos]] es la parte del sistema operativo que se encarga de decidir qué proceso emplea el procesador en cada instante, por tanto, es el encargado de implementar la multiprogramación.

Estados de los procesos

2012-01-29T12:57:40Z

Migoligon: poner titulo

= 3.2 Estados de los procesos =

Todo proceso en un sistema operativo presenta un estado que indica la situación de la ejecución en que se encuentra. El número de posibles estados varía de un sistema operativo a otro.

== Diagrama de estados simplificado ==

Consideramos que todo proceso puede estar, como mínimo, en uno de los siguientes tres estados:

* '''Activo''': el proceso está empleando la CPU, por tanto, está ejecutándose. Pueden haber tantos procesos activos como procesadores haya disponibles. Por tanto, si el sistema dispone de un único procesador, únicamente puede haber un proceso activo a la vez.
* '''Preparado''': el proceso no está ejecutándose pero es candidato a pasar a estado activo. Es el planificador el que, en base a un criterio de planificación, decide qué proceso selecciona de la lista de procesos preparados para pasar a estado activo.
* '''Bloqueado''': el proceso está pendiente de un evento externo que le ha hecho bloquear, tales como una operación de lectura/escritura, la espera de finalización de un proceso hijo, una señal o una operación sobre un semáforo. El dispositivo/hecho externo "avisa" al S.O. cuando ha terminado la acción que realizaba mediante una INTERRUPCIÓN, dejando el S.O. lo que está haciendo para atender a esta última. Tras esto, el S.O. comprueba cuales son los procesos que fueron bloqueados por ese evento externo, cambiándolos al estado de preparado.

La transición de activo a preparado y viceversa depende de decisiones tomadas por el '''planificador del sistema operativo''' en base a un cierto criterio. La transición de activo a bloqueado, y de bloqueado a preparado puede inducirlas el programador mediante llamadas al sistema.

[[Archivo:SSOO2.jpg]]

Hay tres posibles situaciones en las que se ejecutará el planificador del sistema operativo:
* El proceso que se encuentra en el estado activo hace una llamada al sistema que, por su naturaleza, resulta en una transición al estado bloqueado. Este es el caso de las llamadas read(), write(), wait(), pause(), entre muchas otras. Al pasar a estado bloqueado, se invoca al planificador para que decida que otro proceso se asignará al procesador.
* Si el proceso que se encuentra en el estado activo excede el tiempo máximo de asignación, en caso de que lo hubiere.
* Si el proceso que hasta ese momento se encontraba en estado activo termina de ejecutar su código.

Además, algunos sistemas operativos disponen de un estado terminado en el que los procesos pasan antes de terminar su ejecución.

En el caso del núcleo de Linux, existen tres tipos de estados bloqueado y dos estados terminado: http://www.ibm.com/developerworks/linux/library/l-task-killable/

Multiprogramación

2012-01-29T12:49:42Z

Migoligon: poner titulos y resaltar

=3.1 La Multiprogramación =

La multiprogramación es una técnica de multiplexación que permite la ejecución simultánea de múltiples procesos en un único procesador. En realidad, esta técnica produce una ilusión de paralelismo, de manera que parece que todos los procesos se están ejecutando a la vez. Sin embargo, hay un único proceso ejecutándose en el procesador a la vez.

Un método para la multiprogramación es el Foreground/Background (o ejecución jerarquizada) (usado en sistemas por tandas, nunca en interactivos), en él hay un proceso prioritario (el foreground (FG)) que se ejecuta con preferencia de todos los demás, cuando este proceso solicita una operación L/E, mientras el s.o. la realiza, el proceso FG estará bloqueado por esta operación y le cede el control al proceso background 1 (BG), y si éste realiza una operación L/E, al BG2,… Cuando uno de los procesos bloqueados se desbloquea, recibe el control del procesador. Para que este método funcione de forma óptima la mejor forma es colocar los procesos ordenados de mayor a menor cantidad de operaciones L/E.

El siguiente diagrama de ejemplo representa el uso del procesador por tres procesos:

[[Archivo:Uso_del_procesador_general.svg]]

Como se puede observar en el ejemplo anterior, los procesos '''alternan periodos''' en los que '''progresan''' en su actividad, cuando están asignados al procesador, con periodos de inactividad, en los que '''no progresan''' en absoluto.

Si los periodos de inactividad son los suficientemente pequeños como para que el usuario del sistema operativo no los note, que en práctica se traduce a periodos de inactividad de menos de 100ms, el efecto causado es una ilusión de paralelismo. En caso contrario dará una sensación de que se producen "saltos".

El [[planificador de procesos|planificador de procesos]] es la parte del sistema operativo que se encarga de decidir qué proceso emplea el procesador en cada instante, por tanto, es el encargado de implementar la multiprogramación.

Conceptos básicos

2012-01-29T12:10:01Z

Migoligon: añadir enlace y resaltar el proceso zombie

= 2.1. Conceptos básicos =
A continuación se desarrollan conceptos básicos que se emplearán a lo largo de la asignatura.

== Programa ==

Un programa es una secuencia de instrucciones que, al ejecutarse, desarrolla algún tipo de actividad.

Un programa, generalmente, se expresa en un lenguaje de programación de medio u alto nivel (tales como C, C++, Python, Java, Perl, Php, C#, etc) que, mediante un compilador o máquina virtual, se traduce a instrucciones de bajo nivel que corresponden al juego de instrucciones que ofrece el procesador.

El juego de instrucciones del procesador viene determinado por el fabricante.

== Proceso ==

Un ''proceso'' es una instancia de un programa que está en ejecución. De partida todo proceso dispone de una única línea de ejecución. Se puede entender como la vista dinámica (en ejecución) de un programa.

=== Procesos en sistemas operativos tipo Unix ===

* Todo proceso en un sistema operativo tipo Unix tiene un proceso padre y a su vez puede disponer uno o más de un proceso hijo.

* Todo proceso en un sistema operativo tipo Unix tiene un propietario, que se trata del usuario que ha lanzado dicho proceso.

* El proceso ''init'' es el padre de todos los procesos. Es la excepción a la norma general, pues no tiene padre.

* La informacion necesaria para administrar un proceso se guarda en una estructura controlada por el S.O. llamada Bloque de Control de * Procesos o PCB (Process Control Block)

* Para mostrar la relación actual de procesos en el sistema se puede emplear la orden ''ps''.

* Para identificar los procesos el sistema operativo Unix asigna un numero de identificacion del proceso, o pid(Process IDentification).

<source lang="bash">
$ ps -ef
UID PID PPID C STIME TTY TIME CMD
root 1 0 0 11:48 ? 00:00:00 /sbin/init
...
practica 1712 1 18 12:08 ? 00:00:00 gnome-terminal
practica 1713 1712 0 12:08 ? 00:00:00 gnome-pty-helper
practica 1714 1712 20 12:08 pts/0 00:00:00 bash
practica 1731 1714 0 12:08 pts/0 00:00:00 ps -ef
</source>

La primera columna indica el UID del proceso, la segunda el PID, la tercera el PID del proceso padre. Por último, aparece el nombre del proceso en cuestión.

=== Procesos padre e hijo ===

* Todo proceso (padre) puede lanzar un proceso hijo en cualquier momento, para ello el sistema operativo nos ofrece una llamada al sistema que se denomina ''fork''.

* Un proceso hijo es un proceso clon del padre. Sin embargo, procesos padre e hijo no comparten memoria, son completamente independientes.

* Todo proceso padre es responsable de los procesos hijos que lanza, por ello, todo proceso padre debe recoger el resultado de la ejecución de los procesos hijos para que estos finalicen adecuadamente. Para ello, el sistema operativo ofrece la llamada ''wait'' que nos permite obtener el resultado de la ejecución de uno o varios procesos hijo.

* Si un proceso padre no recupera el resultado de la ejecución de su hijo, se dice que el proceso queda en estado '''zombi'''. Un proceso hijo zombi es un proceso que ha terminado su ejecución y que está pendiente de que su padre recoja el resultado de su ejecución.

== [[Llamadas_al_sistema|Llamadas a sistema ]]==

* Se implementan a través de una interfaz (o API) que ofrece el Sistema Operativo. Son mecanismos que el S.O. pone a disposición de los procesos para solicitar un servicio o recurso. (Otra definición, según Wikipedia: Llamadas que ejecutan los programas de aplicación para pedir algún servicio al SO.) Estas llamadas a sistema evitan que el proceso acceda directamente a los recursos del hardware.
En el caso de Linux tiene aproximadamente 350 llamadas al sistema en la versión 3.0.0.
La mayor parte de los Sistemas Operativos suelen implementar la API POSIX por razones de portabilidad.

== Usuario ==

* Sujeto que interactúa con la computadora. Puede ser un humano o un autómata (software).

* En sistemas UNIX encontramos un código único para cada uno, el UID (User IDentifier). A su vez debe pertenecer a un grupo, definido por el GID (Group IDentifier).

== [[Introducción_en_la_administración_de_archivos#Fichero|Fichero ]]==

* Estructura de datos que almacena información.

Los ficheros se identifican mediante su nombre y su extension (un apendice que se utiliza para indicar el tipo de informacion que contiene el fichero).

El lugar donde se encuentra un fichero viene dado por su directorio. Dentro de un directorio pueden existir otros directorios (llamados subdirectorios) lo que da lugar a una organizacion en forma de arbol.

Al camino que debemos seguir para encontrar un fichero lo llamamos '''camino absoluto (absolute path)''', y al camino que debemos seguir para encontrar el fichero en relación a otro fichero, que no sea el fichero raíz, se le conoce cómo '''camino relativo (relative path)'''.

Componentes básicos de un sistema operativo

2012-01-29T12:02:26Z

Migoligon: /* 2.2. Componentes básicos de un Sistema Operativo */ ponerlo un poco más estudiable

=2.2. Componentes básicos de un Sistema Operativo =

Los componentes básicos de un sistema operativo son los siguientes:

===[[Planificador_de_procesos|Gestión de procesos]]===

Un procesador se dedica exclusivamente a un proceso, con todos sus recursos, no puede dedicar unos recursos a un proceso y el resto a otro proceso simultáneamente. Incluye:
* Planificación de procesos: se trata de la parte del sistema operativo que decide qué proceso emplea el procesador en cada instante de tiempo.
* Mecanismos de comunicación entre procesos: permiten comunicar a dos procesos del sistema operativo, tales como la mensajería.
* Mecanismos de sincronización: permiten coordinar a procesos que realizan accesos concurrentes a un cierto recurso.

===[[Introducción| Administración de memoria principal]]===

Tiene como objetivo la gestión de la memoria principal, lo que incluye la gestión del espacio de memoria principal libre y ocupada, así como la asignación de memoria principal a los procesos.

===[[Introducción_en_la_administración_de_archivos| Administración de ficheros]]===

Gestiona la manera en que la información se almacena en dispositivos de entrada/salida que permiten el almacenamiento estable.

===[[GestionES|Gestión de los dispositivos de entrada/salida (driver)]]===

Parte del sistema operativo que conoce los detalles específicos de cada dispositivo, lo que permite poder operar con él.

Además, el sistema operativo ofrece una serie interfaces:

* Llamadas al sistema: conjunto de servicios que los procesos pueden solicitar al sistema operativo.
* Lanzador de aplicaciones: permite el lanzamiento de un programa. Esto incluye los intérpretes de órdenes textuales y los basados en gestores de ventanas.

Tipos de Sistemas Operativos

2012-01-29T11:39:49Z

Migoligon: /* 1.3.1. Según cuántas aplicaciones pueda ejecutar a la vez */ poner en negrita parte del texto

= 1.3. Tipos de Sistemas Operativos =
== 1.3.1. Según cuántas aplicaciones pueda ejecutar a la vez ==

=== '''Monoprogramables'''===
*En un determinado instante de tiempo, '''sólo hay un único proceso en ejecución que monopoliza todos los recursos''' del sistema.
*Principal ventaja: su sencillez.
* Generalmente, no tienen mecanismos de protección de memoria (esta característica los hace más proclives a virus).
*Dos subtipos:
**Ofrece intérprete de órdenes.
**Ofrece entrada a través de cinta/switches (SSOO históricos).
*Ejemplo: DOS.

=== '''Multiprogramables''' ===
*Permiten ejecutar '''múltiples procesos en un único procesador'''. Se tienen varios programas cargados simultáneamente en la memoria, así que el SO debe controlar los accesos y los espacios de la misma.
*Tienen mecanismos de protección del espacio de memoria (el SO impide que una aplicación acceda al espacio de memoria de otra).
====Características que pueden presentar:====
**Multiprogramación: se ejecutan varios procesos simultáneamente de manera que se reparte el uso del procesador. A esta característica también se le llama (de forma imprecisa) "Multitarea".
**Multiusuario: admite múltiples usuarios trabajando simultáneamente.
**Multiacceso: el sistema ofrece varios terminales (mecanismos) para acceso concurrente a él.
**Multiprocesamiento o multiprocesadores: soporta más de un procesador y hace uso de todos ellos.
***Tipos de sistemas multiprocesadores: Podemos diferencias 3 tipos: especializados, con acoplamiento débil y con acoplamiento fuerte:
****Sistemas multiprocesadores con procesadores especializados: Son sistemas que cuentan con un procesador de propósito general y varios procesadores especializados (como por ejemplo coprocesadores aritméticos o el procesador de una tarjeta gráfica). Dichos procesadores especializados solo son capaces de ejecutar un conjunto de operaciones especificas y funcionan únicamente cuando el procesador general se lo solicita, en ese momento colaboran con el procesador general.
****Sistemas multiprocesadores con acoplamiento débil: Son sistemas con procesadores relativamente independientes, cada uno tiene su propia memoria y sus propios canales de E/S.
****Sistemas multiprocesadores con acoplamiento fuerte: Son sistemas con varios procesadores de propósito general independientes entre sí pero que comparten la memoria y trabajan bajo un sistema operativo común.
**Tiempo real: intenta garantizar que determinadas tareas se ejecuten en un plazo de tiempo determinado. Atendiendo al nivel de exigencia, se subdividirían en dos: soft (suave) o '''flexible''' y hard(duro) o '''estricto'''. Un ejemplo puede ser el sistema operativo de tiempo real instalado en el procesador de un teléfono móvil; si llega una llamada tiene que pasarla en ese momento, sino ese proceso deja de ser importante.
**Distribuido: permite la ejecución de múltiples procesos en diferentes máquinas comunicadas por un enlace de red. El primer SO en soportar esta característica fue [http://es.wikipedia.org/wiki/Plan_9_from_Bell_Labs Plan 9] de ''Bell Labs''.

== 1.3.2. Según cómo se presta el servicio ==

*a. Por tanda
**Actividades que se realizan por lote y en serie (una detrás de otra).

*b. Interactivos
**Varias actividades en ejecución intercalándose.

*c. Tiempo Real
**Actividades o sucesos externos al sistema, que se atienden por interrupción y que se deben de procesar en tiempo breve y limitado, **produciendose una degradación de la información. Ejemplo Control de la temperatura en procesos industriales.

*d. Combinados
**En los combinados se combinan los dos primeros, en los que dependerá del proceso que se esté ejecutando.

Qué es un Sistema Operativo

2012-01-29T11:22:49Z

Migoligon: /* 1.1.1. ¿Qué es un Sistema Operativo? */ reordenar, aclarar, poner tildes

= 1.1. ¿Qué es un Sistema Operativo? =
== 1.1.1. ¿Qué es un Sistema Operativo? ==
Es el programa o conjunto de programas que:

*Efectúan la '''gestión de los recursos''' que ofrece un sistema informático:
**La [http://es.wikipedia.org/wiki/Unidad_central_de_procesamiento CPU] (unidad central de procesamiento o procesador).
**La [http://es.wikipedia.org/wiki/Memoria_principal Memoria principal] o memoria RAM.
**Los [http://es.wikipedia.org/wiki/Entrada/salida#Dispositivos_de_entrada_y_salida dispositivos de Entrada/Salida], tales como la tarjeta de vídeo, la tarjeta de red, los dispositivos de almacenamiento masivo (disco duro, memoria flash), los dispositivos USB, teclado, ratón...

*Ofrece un '''lanzador de aplicaciones''', que puede ser de dos tipos:
**Intérprete de órdenes/comandos (traducción defectuosa del original inglés ''command'', que significa orden), también llamado ''shell''. Las órdenes se escriben con el teclado.
**Gestor de ventanas: las órdenes se dan con el ratón. Los sistemas operativos de hoy en día ofrecen ambos tipos de lanzadores de aplicaciones, pero la más utilizada es el gestor de ventanas.

*Ofrece una '''interfaz (API)''' a las aplicaciones para solicitar recursos. El SO hace de intermediario, el programa no accede al hardware directamente a obtener los recursos, sino que se los solicita al SO. Esta interfaz ha de ser estable (es decir, que no cambie con el tiempo) y homogénea.

== 1.1.2. Principios de diseño de un buen Sistema Operativo ==

Los aspectos a tener en cuenta respecto a la gestión de recursos son:

* Realizar una gestión eficiente de los recursos.
* Coordinar la asignación de los mismos (como un moderador en un debate, asignando el turno de palabra).
* Hacer un reparto equitativo de ellos.
* No permitir que las aplicaciones accedan directamente a los recursos sino que sea a través del sistema operativo.

Respecto a la API, debe:

* Ser estable, no debe cambiar con el tiempo.
* Ser homogénea.
* Ocultar los detalles de bajo nivel de los componentes, ofreciendo una capa de abstracción sobre el material (hardware).

Además, otro criterio a tener en cuenta por un buen sistema operativo es la portabilidad, es decir, que soporte diferentes arquitecturas, como por ejemplo la ARM (teléfonos móviles), la x86 de Intel(32 bits), los actuales Intel64 y AMD64(64 bits), la SPARC (desarrollada por Sun Microsystems, ahora adquirida por Oracle), la PowerPC (creada por la alianza AIM: Apple-IBM-Motorola)...

== 1.1.3. Resumen ==

En resumen, un sistema operativo debe tener las siguientes características:

* '''Conveniencia:''' un sistema operativo hace más conveniente el uso de una computadora.
* '''Eficiencia:''' el sistema operativo permite que los recursos de la computadora se usen de manera correcta y eficiente.
* '''Habilidad para evolucionar:''' un sistema operativo debe de ser capaz de aceptar nuevas funciones sin que tenga problemas.
* '''Encargado de administrar el hardware:''' el sistema operativo debe de ser eficaz.
* '''Relacionar dispositivos'''

Sol-ejer3-planif-procesos

2012-01-28T19:17:37Z

Migoligon: /* Nueva Duda: */ proceso que termina antes de bloquearse.

= Ejercicio 3 =

Datos del problema:
| Pa | Pb | Pc | Pd |
--------------------------
H0 | 0 | 1 | 2 | 3 |
--------------------------
t | 4 | 4 | 12 | 12 |
--------------------------

Pa y Pb bloquean por operación de E/S tras 1 unidad de ejecución

< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
X = se ejecuta el código del planificador
↑ = promociona porque ha consumido el quantum.
B = Bloquea.
!!!= Indica que la cola sobre la que se itera ha cambiado

| 1 | | | | | | 2 | | | | | | | | | | 1 | | 2 | |
Pa <---B | | | | |---B | | | | | | | | |---B |---> |
| | 1 | | | | | | 2 | | | | | | | | | | 1 | | 2 |
Pb | <---B | | | | |---B | | | | | | | | |---B |--->
| | | 1 | ↑ | | | | | | | 1 | | | | | | | | | |
Pc | | <---|---| | | | |---|---|---|---| | | | | | | | |
| | | | | 1 | ↑ | | | | | | | | | 1 | | | | | |
Pd | | | < |---|---| | | | | | |---|---|---|---| | | | |
Plnf X X X | X | X X X | | | X | | | X | | | X
|___|___|___|___|___|___|___|__!!!__|___|___|___|___|___|___|__!!!__|___|___|__!!!
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

... continuación ...

| | | | | | | | | | | | |
Pa | | | | | | | | | | | | |
Pb | | | 1 | | | | | | | 1 | | |
Pc |---|---|---|---| | | 1 | |---|---> | 1 |
Pd | | | | |---|---|---|---| | |---|--->
Plnf | | | | X | | | X | X | |
|___|___|___|___|___|___|___|__!!!__|___|___|___|
20 21 22 23 24 25 26 27 28 29 30 31 32

Cálculo de índices:

| Pa | Pb | Pc | Pd |
--------------------------
t | 4 | 4 | 12 | 12 |
--------------------------
T | 19 | 20 | 30 | 32 |
--------------------------
T/t |4.75| 5 | 2.5 |2.66|
--------------------------

*He añadido sobre cada proceso el número de vez de iteración de la cola a la que pertenece. Así se puede ver que por cada dos iteraciones de una cola, se hace una iteración de la otra.
* Notese que en el instante 28, se itera sobre la cola 2 dos veces, pero al no contener elementos la iteración es nula, y se pasa a la siguiente cola prevista.

Explicación:

Todos los procesos empiezan inicialmente en la segunda cola. Pa y Pb reciben una oportunidad de ejecución sin consumir su quantum debido a bloqueo, por tanto, permanecen en la segunda cola. Pc y Pd consumen todo su quantum, por tanto, promocionan a la primera cola. Los procesos Pa y Pb se ejecutan otra vez, pues los procesos que se encuentran en la segunda cola reciben dos oportunidades de ejecución. Tras esto, los procesos recién ascendidos a la primera cola, que son Pc y Pd, reciben su oportunidad de ejecución, en este caso con quantum de 4 unidades. De nuevo, se le da oportunidad de ejecución a los procesos de la segunda cola, que terminan su ejecución. Como no hay más procesos en la segunda cola, se le da una oportunidad de ejecución a los de la primera. --[[Usuario:Pneira|Pneira]] 18:36 22 mar 2011 (UTC)

= Dudas =

No entiendo por qué en la unidad de tiempo 18 no aparece el proceso c y d y posteriormente a b c y d.Esto es a lo que me refiero --[[Usuario:Jherrera|Jherrera]]:

| | | | | | | | | | | | |
Pa | | | | | | | | |---> | | |
Pb | | | | | | | | | |---> | |
Pc |---|---|---|---| | | | | | |------->
Pd | | | | |---|---|---|---| | | | |------>
Plnf | | | | X | | | X | X | X
|___|___|___|___|___|___|___|___|___|___|___|___|
18 19 20 21 22 23 24 25 26 27 28 29 30

Solucion: Por que en la 2ª cola estan los procesos A y B, por que nunca consumen los quantums, y la 2ª cola siempre se itera 2 veces.

¿No se supone que la cola 1 posee mayor prioridad que la 2? siendo asi, mientras C y D esten en la 1ª cola no se le debería volver a dar oportunidad a la cola 2 no?¿--[[Usuario:DvS 013|DvS 013]]

Creo que se lo que dices. Aunque C y D esten en la primera cola, se pasa a la segunda. Esto es porque la primera cola no tiene mas prioridad, sino solo un quantum más ancho. Entonces se mira la primera cola, luego 2 veces la segunda, y vuelta a empezar --[[Usuario:PCamino|PCamino]]

El problema creo yo es que el enunciado ha sido modificado de esta mañana para acá, porque yo también hice el ejercicio para subirlo a la wiki, pero se me adelantaron, y esta mañana en el enunciado ponia que la cola 1 tenia más prioridad que la 2, y ademas no ponia el tiempo que estaban en estado bloqueado los procesos, ahora si lo pone, y no pone lo de la prioridad. Yo estoy de acuerdo con la solucion propuesta arriba. --[[Usuario:Josmorgav1|Josmorgav1]] 21:42 22 mar 2011 (UTC)

Vaya caos! Podemos poner ambos ejercicios --[[Usuario:PCamino|PCamino]]

Con respecto a la prioridad de las colas multinivel realimentadas, creo que carecen de prioridad, simplemente basta con saber cuantas veces se ejecutan cada una y en cual de ellas se meten los procesos que van llegando.--[[Usuario:Jmf bsk|Jmf bsk]] 23:10 22 mar 2011 (UTC)

DUDA: Creo que este ejercicio está hecho para tiempos de bloqueo de 2 unidades, mientras que en el enunciado los tiempos de bloqueo es de 1 t. Si fuera para tiempos de bloqueo = 1 en el instante 2 Pa regresa a la cola 2 de preparados, luego pasaría a estado activo antes que Pd , por lo que en t=4 Pa pasaría a estado activo,después iría Pd y después la segunda ejecución de Pb. Lo escribo para aclararlo:

Pa y Pb bloquean cada unidad de tiempo, durante una unidad de tiempo de bloqueo.

| | | | | | | | | | | | | | | | | | | | |
Pa <---| | | |---| | | | | | | | | | | |---| |---> |
Pb | <---| | | | | |---| | | | | | | | | |---| |--->
Pc | | <---|---| | | | |---|---|---|---| | | | | | | | |
Pd | | | < | |---|---| | | | | |---|---|---|---| | | | |
Plnf X X X | X X | X X | | | X | | | X | | | X
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

¿es correcta la solución que planteo para una unidad de tiempo de bloqueo?

----------------------------------------------------------------------------------------------

==='''Nueva Duda:'''===

Si sobre la cola 2 se itera dos veces, porque no se vuelve al Pa y Pb en el instante de tiempo 8? Como sucede en el instante 18.

R:
Fijate que en el instante de tiempo t=6 ya es la 2ª vez que se itera sobre Pa y Pb, la diferencia radica en que en la cola 2 inicialmente existian cuatro procesos que había que atenderlos en RR, añadiendo que Pa y Pb bloquean cada 1 UT, a diferencia del intante t=18 solo existen Pa y Pb y como dice el enunciado se les da dos oportunidades de ejecucion si no consumen su quantum.
--[[Usuario:Albsolnog|Albsolnog]] 11:53 13 nov 2011 (UTC)

R1:
Añado para mayor comprensión del ejercicio que en el instante t=6 empieza la segunda iteración de la cola 2, lo que pasa es que en esta iteración nada más que entran Pa y Pb, ya que los procesos Pc y Pd han consumido su quantum entero y han promocionado a la cola 1. --[[Usuario:Josazcrom|Josazcrom]] 18:55 22 nov 2011 (UTC)

P:No terminaría el proceso A y el B justo después de hacer el bloqueo? Porqué en el ejercicio termina justo antes de ser bloqueado incluso?

Sol-ejer3-planif-procesos

2012-01-28T19:15:52Z

Migoligon: /* Ejercicio 3 */ aclarar cosas

Criterios de planificación

2012-01-28T18:53:00Z

Migoligon: /* Colas multinivel con realimentación (feedback) */ añadir un comentario para una posible errata.

=4.3.1 Métodos no apropiativos =

El procesador es asignado al proceso hasta fin de ejecución. Suele darse en sistemas operativos monoprogramables y sistemas de tiempo real.
En los métodos no apropiativos, si el proceso se bloquea o entra en estado bloqueado, el procesador quedará sin uso durante todo ese tiempo, pues estaba dedicado/reservado para ése proceso.

== Estocástico ==

Se selecciona aleatoriamente el proceso a ser asignado al procesador. No cumple varios [[Planificación de procesos#Aspectos para diseñar un buen planificador|aspectos de diseño de un buen planificador]], como repetitividad o predecibilidad. Es un criterio de planificación teórico que sirve de referencia, si se emplea un criterio de planificación que ofrece resultados peores que la planificación de procesos estocástica, entonces es que no se trata de un buen criterio de planificación.

No se ofrece un ejemplo, puesto que para un conjunto de procesos existen tantas trazas de ejecución como posible combinaciones aleatorias.

== Con conocimiento del futuro ==

En base al conocimiento del futuro se asignan los procesos. Se trata también de un criterio de planificación teórico. Si un criterio de planificación se acerca al criterio de planificación con conocimiento de futuro, entonces es que se trata de un buen planificador.

Ejemplo:

____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|
Datos del _H0_|_0__|_1__|_3__|_6__|_7__|
problema _t__|_3__|_5__|_2__|_3__|_1__|

< = lanzamiento del proceso
> = finalización del proceso
x = indica que el proceso está asignado al procesador en ese momento
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pd |---|---|---|---|---|---<---|---|---|---|---|xxx|xxx|xxx>---|---|---|---|---|---|
Pe |---|---|---|---|---|---|---<---|---|---|xxx>---|---|---|---|---|---|---|---|---|
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|
Cálculos _t__|_3__|_5__|_2__|_3__|_1__|
de tiempos _T__|_3__|_9__|_2__|_8__|_4__| z = índice de penalización
_z__|_1__|_9/5|_1__|_8/3|_4/1|

En este ejemplo, al conocer los tiempos en los que llegará cada proceso, y el tiempo de proceso, podemos buscar la forma de asignarlos de forma que, por ejemplo, consigamos la mínima penalización.

== Por orden de llegada (First In, First Out: FIFO) ==

Se selecciona el proceso por orden de llegada al sistema, cuando un proceso está preparado se añade al final de la cola y se ejecuta según el orden de incorporacion. Su principales ventajas son su facilidad de implementación, consume muy poco tiempo de procesador (casi ninguno) y su orden de complejidad, O(1). Su desventaja es que los procesos de corta duración pueden quedar a la espera de procesos muy prolongados, así que presentarán un alto índice de penalización.

Ejemplo:

____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|
problema _t__|_3__|_5__|_2__|_5__|_5__|

< = lanzamiento del proceso
> = finalización del proceso
x = indica que el proceso está asignado al procesador en ese momento
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|
Pc |---|---|---<---|---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx>
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_| t = tiempo de ejecución
Cálculos _t__|_3__|_5__|_2__|_5__|_5__| T = tiempo de terminación (Instante de
de tiempos _T__|_3__|_7__|_7__|_6__|_8__| terminación - Instante de lanzamiento)
_z__|_1__|_7/5|_7/2|_6/5|_8/5| z = índice de penalización

== El siguiente, el más corto (Shortest Job First: SJF) ==

Se selecciona el proceso que requiera menos tiempo de ejecución de entre todos los que están listos para ejecutarse. Se necesita conocer con antelación el tiempo de ejecucion de cada proceso, algo que es muy dificil en muchas ocasiones.
Para procesos largos puede presentar un índice de penalización elevado: Si se tienen muchos procesos cortos, el de mayor duración puede quedar en espera indefinidamente. Otro inconveniente es que todo trabajo corto que llegue cuando ya ha comenzado un trabajo largo tiene un gran retraso. Su orden de complejidad es O(n).

Ejemplo:

____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|
Datos del _H0_|_0__|_1__|_3__|_9__|_12_|
problema _t__|_3__|_5__|_2__|_5__|_5__|

< = lanzamiento del proceso
> = finalización del proceso
x = indica que el proceso está asignado al procesador en ese momento
& = se ejecuta el planficador
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pb |---<---|---|---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|
Pc |---|---|---<xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pd |---|---|---|---|---|---|---|---|---<---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|
Pe |---|---|---|---|---|---|---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|xxx|xxx>
planif. &---|---|---&---|---&---|---|---|---|---&---|---|---|---|---&---|---|---|---|---&
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|
Cálculos _t__|_3__|_5__|_2__|_5__|_5__|
de tiempos _T__|_3__|_9__|_2__|_6__|_8__| z = índice de penalización
_z__|_1__|_9/5|_1__|_6/5|_8/5|

== Basado en índice de penalización ==

Se selecciona el proceso que tendrá el índice de penalización <math>I_p=\frac{T}{t}=\frac{H_f-H_0}{t}</math> de mayor valor. Este método puede producir aplazamientos de ejecución de procesos,pero no son indefinidos. Su orden de complejidad es <math>O(n)</math>.

Ejemplo:

____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|
Datos del _H0_|_0__|_1__|_3__|_7__|_6__|
problema _t__|_3__|_5__|_4__|_3__|_5__|

< = lanzamiento del proceso
> = finalización del proceso
x = indica que el proceso está asignado al procesador en ese momento
& = se ejecuta el planficador

|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pa <xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pb |---<---|---|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|
Pc |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|
Pd |---|---|---|---|---|---|---<---|---|---|---|---|xxx|xxx|xxx>---|---|---|---|---|
Pe |---|---|---|---|---|---<---|---|---|---|---|---|---|---|---|xxx|xxx|xxx|xxx|xxx>
planif.&---|---|---&---|---|---|---|---&---|---|---|---&---|---|---&---|---|---|---|---&
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|
Cálculos _t__|_3__|_5__|_4__|_3__|_5__|
de tiempos _T__|_3__|_7__|_9__|_13_|_11_|
z(3)|_1__|_'''7/5'''|_1__|____|____|
z(8)|_1__|_7/5|_'''9/4'''|_4/3|_7/5|
z(12)|_1__|_7/5|_9/4|_'''8/3'''|11/5| z = índice de penalización
z(15)|_1__|_7/5|_9/4|_8/3|'''14/5'''|
z(20)|_1__|_7/5|_9/4|_8/3|14/5|

=4.3.2 Métodos apropiativos =

El planificador puede retirar el procesador en cualquier momento al proceso activo. Se emplea fundamentalmente en sistemas operativos [[Multiprogramación|multiprogramables]].

Con métodos apropiativos, la decisión de planificación tiene lugar si:

* El proceso activo pasa a estado bloqueado.
* El proceso activo termina su ejecución.
* Se lanza un nuevo proceso.
* El proceso activo agota el tiempo máximo de asignación del procesador (veáse ''Turno Rotatorio'').

== El siguiente, el más corto (Shortest Job First: SJF) ==

Se selecciona el proceso que requiera menos tiempo de ejecución. Si hay un proceso en estado preparado que requiere menos tiempo de ejecución del que le falta al actual, se le retira el procesador al actual proceso y se le asigna al nuevo. Su orden de complejidad es O(n), pero, a diferencia del no apropiativo, cuando entra un proceso en la lista de procesos, se ejecuta código de planificador.Con este método los procesos más largos se ven perjudicados, pues se puede retrasar tanto su tiempo de inicio, como el de finalización.

Ejemplo:

____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|
Datos del _H0_|_0__|_1__|_4__|_6__|_12_|
problema _t__|_3__|_5__|_1__|_8__|_3__|

< = lanzamiento del proceso
> = finalización del proceso
x = indica que el proceso está asignado al procesador en ese momento
$ = indica la ejecución del planificador para retirar un
proceso y establecer otro según el criterio
& = se ejecuta el código del planificador
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pa <xxx|xxx|xxx>---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pb |---<---|---|xxx|---|xxx|xxx|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|
Pc |---|---|---|---<xxx>---|---|---|---|---|---|---$---|---|---|---|---|---|---|---|
Pd |---|---|---|---|---|---<---|---|---|xxx|xxx|xxx|---|---|---|xxx|xxx|xxx|xxx|xxx>
Pe |---|---|---|---|---|---|---|---|---|---|---|---<xxx|xxx|xxx>---|---|---|---|---|
Planif.|---&---|---&---&---&---&---|---|---&---|---|---&---|---|---&---|---|---|---|---&
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

____|_Pa_|_Pb_|_Pc_|_Pd_|_Pe_|
Cálculos _t__|_3__|_5__|_1__|_8__|_3__|
de tiempos _T__|_3__|_8__|_1__|_11_|_3__| z = índice de penalización
_z__|_1__|_8/5|_1__|11/8|_1__|

== Por prioridades ==

Se establecen índices de prioridad a cada proceso:

* '''Índice estático''': Establecido por el usuario. En el caso de sistemas operativos tipo Unix, se dispone de una índice denominado ''nice value'' cuyos valores están entre -20 (máxima prioridad) y 19 (mínima prioridad).
* '''Índice dinámico''': Establecido por el planificador, inicialmente basado en el índice estático, después se va recalculando en base a las observaciones que realiza el planificador sobre el comportamiento de los procesos, aumentándola cuando un proceso está a la espera o disminuyéndola cuando tiene adjudicado el procesador.

El método funciona de la siguiente manera: El planificador mantiene ordenada la cola de procesos preparados, según prioridades decrecientes. Si el proceso en ejecución se bloquea, el planificador selecciona el primero de la lista. Cuando un proceso pasa a la situación de preparado, comprueba si su prioridad es mayor que la del proceso activo. En tal caso, suspende la ejecución de éste, colocándolo al principio de la cola de preparados, y elige al recién llegado; si no, lo inserta en la cola según su prioridad.
Cuando hay varios procesos con la misma prioridad se pueden aplicar diversos criterios, como seguir el orden de llegada a la cola de preparados, o el que necesite menos tiempo para acabar entre otros.

El orden es siempre O(n).

Ejemplo:

____|_Pa_|_Pb_|_Pc_|_Pd_|
Datos del _H0_|_0__|_1__|_2__|_3__|
problema _t__|_2__|_4__|_2__|_7__| p = prioridad estática
_p__|_0__|-20_|_4__|_10_|

< = lanzamiento del proceso
> = finalización del proceso
x = indica que el proceso está asignado al procesador en ese momento
$ = indica la ejecución del planificador para retirar un
proceso y establecer otro según el criterio
& = se ejecuta el código del planificador
|---$---|---|---|---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pa <xxx|---|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pb |---<xxx|xxx|xxx|xxx>---$---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pc |---|---<---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|---|---|
Pd |---|---|---<---|---|---|---|---|xxx|xxx|xxx|xxx|xxx|xxx|xxx>---|---|---|---|---|
Planif. |---&---&---&---|---&---&---|---&---|---|---|---|---|---|---&---|---|---|---|---|
-------|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

____|_Pa_|_Pb_|_Pc_|_Pd_|
Cálculos _t__|_2__|_4__|_2__|_7__|
de tiempos _T__|_6__|_4__|_6__|_12_| z = índice de penalización
_z__|_3__|_1__|_3__|12/7|

== Turno rotatorio ==

=== Turno rotatorio estricto (Round Robin: RR) ===

En este criterio, todo proceso es asignado al procesador durante un tiempo establecido denominado ''quantum'', tras el cual se le retira y se asigna a otro proceso rotatoriamente. De esta manera, los procesos acceden al procesador por turnos.

El tamaño del ''quantum'' es fundamental para determinar el comportamiento de este criterio de planificación.
Si el ''quantum'' empleado es pequeño, por ejemplo de 10 ms, suponiendo que la conmutación de procesos requiere 10ms, el 50% del tiempo se empleará el procesador para ejecutar el código que permite conmutar entre procesos. Sin embargo, si el ''quantum'' empleado es grande, por ejemplo de 5 s, la latencia será mayor, degradando la experiencia del usuario que notará como sus procesos progresan ''a saltos'', puesto que, en el peor de los casos, hasta pasados 5 s no se le asignará el procesador a otro proceso .

Si un proceso bloquea antes de consumir su ''quantum'' '''se le retira el procesador''' y se añade al final de la cola. Esto beneficia a los procesos por lotes, cuyo comportamiento está limitado por el procesador, pues se pasan más tiempo asignados al procesador.

Puesto que el reparto del procesador es estricto, los procesos recién lanzados deben acceder al procesador lo antes posible, por tanto, se les da oportunidad de ejecución por orden de llegada por delante de los procesos en la cola de procesos preparados. De esta manera, se evita que los procesos recién lanzados queden postergados indefinidamente.

Este criterio se puede implementar con una cola, de manera que el orden de complejidad en la selección del proceso que pasa a estado activo es <math>O(1)</math>. Nótese que a mayor número de procesos preparados, mayor tiempo tardará un proceso en volver a pasar a estado activo.

Ejemplo:

____|_Pa_|_Pb_|_Pc_|_Pd_|
Datos del _H0_|_0__|_1__|_2__|_3__|
problema _t__|_2__|_4__|_2__|_7__| quantum = 1 unidad de tiempo

< = lanzamiento del proceso
> = finalización del proceso
x = indica que el proceso está asignado al procesador en ese momento
$ = indica la ejecución del planificador para retirar un
proceso y establecer otro según el criterio
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pa <xxx|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pb |---<xxx|---|---|---|xxx|---|---|xxx|---|xxx>---|---|---|---|---|---|---|---|---|
Pc |---|---<xxx|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|
Pd |---|---|---<xxx|---|---|---|xxx|---|xxx|---|xxx|xxx|xxx|xxx>---|---|---|---|---|
$ $---$---$---$---$---$---$---$---$---$---$---$---$---$---$---$---|---|---|---|---|
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

____|_Pa_|_Pb_|_Pc_|_Pd_|
Cálculos _t__|_2__|_4__|_2__|_7__|
de tiempos _T__|_5__|_10_|_5__|_12_| z = índice de penalización
_z__|_5/2|10/4|_5/2|12/7|

=== Turno rotatorio con compensación ===

Es una variante del anterior. Para no perjudicar a los procesos cuyo comportamiento está limitado por operaciones de entrada/salida, se reinsertan en la cola en proporción al tiempo consumido. Es decir, que si un cierto proceso ha consumido el 25% de su '''quantum''', se reinserta en el 25% de la cola, contando desde el principio (dispondrá de otro quantum completo).
Este tipo de criterio tiene un problema y es que se pueden posponer indefinidamente algunos procesos si hay varios procesos que bloqueen.

Ejemplo:

____|_Pa_|_Pb_|_Pc_|_Pd_| Pa y Pc bloquean cada 1 unidad de tiempo
Datos del _H0_|_0__|_1__|_2__|_3__| El bloqueo se resuelve tras 2 unidades de tiempo
problema _t__|_2__|_4__|_2__|_7__| quantum = 2 unidad de tiempo

< = lanzamiento del proceso
> = finalización del proceso
x = indica que el proceso está asignado al procesador en ese momento
$ = indica la ejecución del planificador para retirar un
proceso y establecer otro según el criterio
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pa <xxx|---|---|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|
Pb |---<xxxxxxx|---|---|---|---|---|xxx|xxx>---|---|---|---|---|---|---|---|---|---|
Pc |---|---<---|xxx|---|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|
Pd |---|---|---<---|xxx|xxx|---|---|---|---|xxxxxxxxxxxxxxxxxxx>---|---|---|---|---|
$ $---$---|---$---$---$---|---$---$---|---$---|---$---|---$---$---|---|---|---|---|
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

____|_Pa_|_Pb_|_Pc_|_Pd_|
Cálculos _t__|_2__|_4__|_2__|_7__|
de tiempos _T__|_7__|_9__|_6__|_12_| z = índice de penalización
_z__|_7/2|_9/4|_6/2|12/7|

=== Turno rotatorio con quantum dependiente del número de procesos ===

Otra variante se trata de emplear un '''quantum''' proporcional al número de procesos que haya en estado preparado. De esta forma se obtiene una progresión más uniforme, y por tanto una mejor experiencia para el usuario. Sin embargo, esto aumenta el número de conmutaciones entre procesos. Para evitar la degradación del rendimiento por un exceso de conmutaciones, se establece un mínimo de manera que el quantum no puede ser menor a éste.

== Colas multinivel ==

En este tipo de criterio se mantienen múltiples colas con los procesos en estado preparado. Los procesos se clasifican en las colas según sus características, cada cola recibe un tratamiento distinto.

Un ejemplo sería el siguiente, compuesto de cuatro colas:

# Esta primera cola es para procesos que poseen menor tiempo de ejecución, son los gestores de interrupción y los gestores de dispositivos (drivers). Hay que tomar los datos y almacenarlos en memoria lo antes posible para poder recoger más, aunque se posponga el procesamiento de dichos datos.
# En esta cola se almacenan los procesos del servidor, tales como : proceso administrador de memoria, administrador de ficheros, administrador de red, etc.
# Esta cola esta reservada a los procesos de usuario (procesos útiles para el usuario). Esta se divide a su vez en dos colas:
## Cola de procesos interactivos, limitados por E/S.
## Cola de procesos por lotes, limitados por el procesador.

Las colas tienen prioridad según su número, por ejemplo mientras que haya procesos preparados en la primera cola, no se mira la segunda. Esto puede dar lugar a que si hay muchos procesos de gestión de dispositivos se degrade la eficiencia del sistema.

La primera cola esta implementada con una FIFO(no apropiativo), mientras que las colas 2 y 3 se basan en un sistema de RR (turno rotatorio).

=== Colas multinivel con realimentación (feedback)===

Es una variante de las colas multinivel en las que los procesos pasan de una cola a otra según su comportamiento, de manera que:

* Los procesos interactivos tienen más oportunidades de emplear el procesador.
* Los procesos por lotes disponen del procesador durante más tiempo.

Los procesos se asignan al procesador por turnos rotatorios, empleando un ''quantum'' dependiente de la cola en la que se encuentren. Los procesos que consumen el ''quantum'' asignado completamente un número determinado de veces pasan a colas en las que se asignan ''quantum'' mayores. Nótese que los procesos que no consumen su ''quantum'' muestran un comportamiento interactivo. Para no discriminar a los procesos que se encuentran en las colas con ''quantum'' menores, se les dan más oportunidades de ejecución.

Por ejemplo, en un sencillo planificador de colas multinivel con realimentación compuesto por dos colas:

* En la primera cola se le asignan un ''quantum'' de 2 unidades de tiempo a los procesos.
* En la segunda cola se le asignan un ''quantum'' de 1 unidad de tiempo a los procesos.

Si un proceso no consume el ''quantum'' asignado dos veces, pasa a la cola en la que en la se le asignan ''quantum'' de 1 unidad de tiempo.

Para que los procesos interactivos no salgan perjudicados, en aras de hacer un reparto del procesador más equitativo, se le dan dos oportunidades de ejecución a los procesos situados en la cola con ''quantum'' de 1 unidad de tiempo. De esta manera, los procesos de la primera cola reciben una oportunidad de ejecución con un ''quantum'' de 2 unidades de tiempo y los de la segunda reciben dos oportunidades de ejecución con un ''quantum'' de 1 unidad de tiempo.

Ejemplo:

Pa y Pc bloquean cada 1 unidad de tiempo
El bloqueo se resuelve tras 2 unidades de tiempo
Colas multinivel: 1. Procesos interactivos (quantum = 1 unidad de tiempo)
2. Procesos por lotes (quantum = 2 unidad de tiempo)
Inicialmente todos los procesos van a la cola 2
Los procesos que no consuman su quantum al menos una vez pasan a la cola 1
Las colas implementan turno rotatorio estricto.
Siempre que haya procesos en la cola 1, debe ser atendidos de manera preferente frente a la cola 2.

____|_Pa_|_Pb_|_Pc_|_Pd_|
Datos del _H0_|_0__|_1__|_2__|_3__|
problema _t__|_2__|_4__|_2__|_7__|

< = lanzamiento del proceso
> = finalización del proceso
x = indica que el proceso está asignado al procesador en ese momento
$ = indica la ejecución del planificador para retirar un
proceso y establecer otro según el criterio
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pa <xxx|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Pb |---<xxxxxxx|---|---|---|---|---|xxxxxxx>---|---|---|---|---|---|---|---|---|---|
Pc |---|---<---|---|xxx|---|---|xxx>---|---|---|---|---|---|---|---|---|---|---|---|
Pd |---|---|---<---|---|xxxxxxx|---|---|---|xxxxxxxxxxxxxxxxxxx>---|---|---|---|---|
$ $---$---|---$---$---$---|---$---$---|---$---|---$---|---$---$---|---|---|---|---|
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

____|_Pa_|_Pb_|_Pc_|_Pd_|
Cálculos _t__|_2__|_4__|_2__|_7__|
de tiempos _T__|_4__|_9__|_6__|_12_| z = índice de penalización
_z__|_4/2|_9/4|_6/2|12/7|

* Si bloquea cada una unidad de tiempo, tanto el proceso A como el proceso C bloquean, entonces no pueden finalizar donde finalizan, si no tras haber procesado el bloqueo, dos unidades de tiempo después.

Hilos

2012-01-28T18:43:40Z

Migoligon: Pasar imagn ascii a svg

* Hilo = "proceso ligero" = línea de ejecución

* En general, el planificador de procesos da el mismo tratamiento a los hilos y a los procesos.

* Proceso inicialmente parte con un único hilo

* El sistema operativo ofrece llamadas al sistema para crear/destruir hilos. Desde el código del programa, puedo hacer uso de estas llamadas al sistema.

* Cuando se crea un hilo, se le indica qué código se quiere que ejecute.

* Dos o más hilos, de un mismo proceso, comparten espacio de memoria.

* La conmutación de hilos es menos costosa que la conmutación de procesos.

Veamos un ejemplo diseñado para un solo procesador:

[[Archivo:Uso_del_procesador_hilos.svg]]

Con multiprocesamiento podemos ejecutar diferentes procesos a la vez. Si tenemos uno solo podemos desdoblarlo en hilos, usando técnicas de programación apoyadas en APIS (como POSIX threads).

Para aumentar su eficiencia, un programa en ejecución debe crear tantos hilos como el doble del número de procesadores del los que disponga el sistema. Por ejemplo: 4 hilos para un programa ejecutado con 2 procesadores.

Las principales ventajas del uso de hilos son:

*Menor penalización en cuanto a conmutación.

*Dos hilos de un mismo proceso pueden compartir memoria aprovechando mejor los recursos y eliminando los mecanismos de comunicación necesarios para soluciones implementadas en varios procesos.

*Con un solo procesador es posible que una línea de proceso haga uso de una llamada al sistema bloqueante. En este caso se puede llamar a otro hilo del mismo proceso en lugar de conmutar a otro proceso externo, ahorrando así tiempo de conmutación asociado a la ejecución del planificador de procesos.

= Ejemplo =

El siguiente es un código en C de ejemplo en el que se muestra la creación de dos hilos. Se hace uso de la llamada al sistema ''sleep'' que hace que el proceso pase a estado bloqueado durante N segundos. Nótese que al compartir la variable ''a'', ambos hilos modifican su valor.

<source lang="c">
#include <stdio.h>
#include <pthread.h>

int a = 10;

void *codigo_hilo1(void *arg)
{
sleep(10);
a = a - 2;
printf("Soy el hilo 1 y la variable a vale %d\n", a);
return NULL;
}

void *codigo_hilo2(void *arg)
{
sleep(5);
a++;
printf("Soy el hilo 2 y la variable a vale %d\n", a);
return NULL;
}

int main(void)
{
pthread_t hilo1, hilo2;

pthread_create(&hilo1, NULL, codigo_hilo1, NULL);
pthread_create(&hilo2, NULL, codigo_hilo2, NULL);

pthread_join(hilo1, NULL);
pthread_join(hilo2, NULL);
}
</source>

Este ejemplo se compila en un terminal escribiendo: '''gcc -lpthread archivo.c'''

Archivo:Uso del procesador hilos.svg

2012-01-28T18:42:30Z

Migoligon:

Sol-ejer2-planif-procesos

2012-01-28T18:41:26Z

Migoligon: /* Turno rotatorio proporcional al número de procesos */ otro fallo más en el problema.

= Turno rotatorio estricto =

____|_PA_|_PB_|_PC_|
Datos del _H0_|_0__|_1__|_2__|
problema _t__|_3__|_5__|_6__|

PA bloquea por E/S cada 1 unidad de tiempo
PB bloquea por E/S cada 3 unidades de tiempo
< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
X = se ejecuta el código del planificador

| | | | | | | | | | | | | | | | | | | |
Pa <---| | | | |---| | | |---| | > | | | | | | |
Pb | <---|---| | | |---| | | |---|---> | | | | | | |
Pc | | < |---|---| | |---|---| | | |---|---> | | | | |
Planificador X X | X | X X X | X X | X | X | | | | |
____|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

_____|_Pa_|_Pb_|_Pc_|
Cálculos __t__|_3__|_5__|_6__|
de tiempos __T__|_10_|_11_|_12_|
_T/t_|3.3_|2.2_|_2__|

Notése que el proceso A no llega a emplear el ''quantum'' que tiene asignado, en ese caso, como indica la [[Criterios_de_planificación|teoría]], se le retira el procesador y el planificador selecciona a otro proceso. Dejar el procesador sin proceso asignado, es decir, ocioso, va contra la lógica del máximo aprovechamiento del procesador. Por ello, he retirado una solución incorrecta que aparecía en esta sección. --[[Usuario:Pneira|Pneira]] 21:15 21 mar 2011 (UTC)

Tengo una duda en este ejercicio, en la unidad de tiempo 6 cuando el planificador activa el proceso Pb, porque motivo solo le asigna una unidad de tiempo?, podria asignarle 2 no? teniendo en cuenta que el quantum = 2. Ademas el proceso B bloquea cada 3 unidades de tiempo, no entiendo porque solo le asigna una unidad y luego activa en la unidad de tiempo 7 el proceso C. LFE (Luis Fernandez Esteban)

Pues yo diría que es porque se bloquea cada 3, al igual que el A se bloquea a cada unidad. Ya llevaba 1, y con esa actividad, +2 --[[Usuario:PCamino|PCamino]]

Gracias, tienes razon ya lo entendi. LFE (Luis Fernandez Esteban)

DUDA
En t=3 llegaría el proceso Pa y el proceso Pb a la cola de estado preparado. Como dice en teroía, un proceso que se bloquea sin llegar a agotar su quantum, pasaría al final de la cola de estados preparados. Por tanto, el siguiente en ejecutarse sería Pb, puesto que Pa viene de estar bloqueado sin agotar su quantum luego pasaría al final de la cola de preparados. ¿Estoy en lo cierto?
--[[Usuario:josvaldia|josvaldia]]

-esto es estricto no por compensación por tanto no estas en lo cierto. --[[Usuario:juacordia|juacordia]]

DUDA: ¿En t=10 el proceso A no bloquearia y terminaria de ejecutarse cuando vuelva del bloqueo? --[[Usuario:jesgonbel|jesgonbel]]

RESP: En t=10, el proceso A no entra en bloqueo, sino que directamente finaliza su ejecución.
--[[Usuario:framorexp|framorexp]]

RESP2: jesgonbel, el proceso terminaría cuando vuelve del bloqueo, no finaliza en el 10, lo haría en el 12 lo dijo pablo en clase creo recordar --[[Usuario:fercarort|fercarort]]

RESP3: Vale, puede ser, pero a efectos prácticos es como si finalizara en el 10, porque tras el bloqueo no necesita ningún tipo de procesamiento. No se si este caso merece algún trato especial, pero creo que no. --[[Usuario:framorexp|framorexp]]

= Por prioridades =

Suponiendo que la prioridad de los procesos es la siguiente: A<B<C

____|_PA_|_PB_|_PC_|
Datos del _H0_|_0__|_1__|_2__|
problema _t__|_3__|_5__|_6__|

PA bloquea por E/S cada 1 unidad de tiempo
PB bloquea por E/S cada 3 unidades de tiempo
< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
X = se ejecuta el código del planificador

| | | | | | | | | | | | | | | | | | | |
PA <---| | | | | | | | | |---| | | |---| | > | |
PB | <---| | | | | | |---|---| | |---|---> | | | | |
PC | | <---|---|---|---|---|---> | | | | | | | | | | |
Planificador X X X | | | | | X | X X X | X | | | | |
____|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|__t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

_____|_PA_|_PB_|_PC_|
Cálculos __t__|_3__|_5__|_6__|
de tiempos __T__|_15_|_13_|_6_|
_T/t_|__5_|_2.6|_1__|

Nota: Del 11 al 12 no se procesa nada porque sólo quedan los procesos A y B, pero en esa unidad de tiempo ambos están bloqueados (los bloqueos de A y B duran 2 uds. de tiempo) --[[Usuario:Pneira|Pneira]] 19:23 8 nov 2011 (UTC)

= Turno rotatorio proporcional al número de procesos =

____|_PA _|_PB_|_PC _|
Datos del _H0_|_0__|_1__|_2__|
problema _t__|_3__|_5__|_6__|

< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
X = se ejecuta el código del planificador
B = bloquea
P = preparado

q=2 q=2 q=1 q=1 q=1 q=2 q=1 q=1 q=1 q=1 q=2
| | | | | | | | | | | | | | | | | | | | |
Pa <---B | P |---B | P |---> | | | | | | | | | | |
Pb | <---|---P | |---B | P |---P |---> | | | | | | | |
Pc | | < |---P | |---|---P | |---P |---|---> | | | | | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

_____|_PA_|_PB_|_PC_|
Cálculos __t__|_3__|_5__|_6__|
de tiempos __T__|_12_|_15_|_17_|
_T/t_|_4__|2.80|_2.5|

Nota: Fíjese en que el quantum se calcula en base al número de procesos que están en estado preparado cada vez que hay que tomar una decisión de planificación --[[Usuario:Pneira|Pneira]] 19:34 8 nov 2011 (UTC)

Los índices de penalización de este ejercicio son erróneos, la solución correcta creo que sería la siguiente:

_____|_PA_|_PB_|_PC_|
Cálculos __t__|_3__|_5___|_6__|
de tiempos __T__|_9__|_11__|_12_|
_T/t_|_3__|_2.2_|__2_|--[[Usuario:Josazcrom|Josazcrom]] 17:28 22 nov 2011 (UTC)

*Aparte de que los índices parecen estar mal, el proceso A no debería terminar donde termina, si no dos unidades de tiempo después, tras terminar el bloqueo.

PREGUNTA:Pienso que en el instante 11 el proceso que se ejecuta es el C ya que en el 10 en la cola de preparado había 1 proceso en estado preparado, por tanto, el quantum vuelve a cambiar a 2 y el proceso C se ejecuta del 10 a 12.
¿Alguién puede confirmarme esta "pregunta"?.
--[[Usuario:Raflopseg|Raflopseg]] 18:20 23 nov 2011 (UTC)

Probablemente no te sea de ayuda ahora pero por si le sirve a alguien:
En el instante 9 B usa solo uno porque C esta activo y por tanto el quantum es 1.
B no pasa a estar bloqueado(se bloquea en el 6 y no se vuelve a usar hasta el 9 por lo tanto esta activo por tres intervalos)
Al estar B activo C solo se puede ejecutar de 10 a 11

Planificación de procesos

2012-01-28T16:15:58Z

Migoligon: Falta título

= Planificación de procesos =
Todo planificador de procesos emplea uno o varios criterios (''scheduling policy'', en inglés) que determinan el criterio de selección del proceso que empleará el procesador.

== Aspectos para diseñar un buen criterio de planificación ==

Además de ofrecer una alta ''tasa de transferencia'' (throughput) y una baja latencia (latency), es deseable que un planificador implemente las siguientes características:

*'''Repetitividad''' : con cargas de trabajo similares(cantidad de procesos a atender) , el procesador debe tener comportamientos similares.
*'''Predecibilidad''' : hace referencia al tiempo de terminación de un proceso para cierta carga de trabajo, que debe ser similar para cargas de trabajo parecidas.
*'''Eficiencia''' : debe tomar decisiones rápidas para aumentar el rendimiento.
*'''Reducción del número de conmutaciones''' : de nuevo, para aumentar el rendimiento y reducir la penalización asociada.
*'''Atención de prioridades''': uso de criterios de selección basados en prioridades
*'''Degradación uniforme del rendimiento''': a mayores cargas de trabajo el rendimiento debe degradarse uniformemente.
*'''Capacidad de respuesta instantánea''': los tiempos de espera para atender a un proceso deben ser aceptables de cara al usuario, generalmente <100ms para seres humanos.

Ejercicios Procesos

2012-01-28T15:39:53Z

Migoligon: /* Ejercicio 2 */ editar fecha

Se muestran a continuación una serie de ejercicios relacionados con el temario de procesos.

Para ver las soluciones a los ejercicios, ir hacia [[solución de los ejercicios de procesos]].

== Ejercicio 1 ==
''[Este ejercicio fue parte del Primer Control de Evaluación Contínua en el curso 2010/11, del 23 de marzo de 2011]''
{| border="2" cellpadding="4" cellspacing="0" style="margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;"
! width="50" style="background:#efefef;" | Proceso
! width="50" style="background:#efefef;" | H0
! width="50" style="background:#efefef;" | t
|-
| PA
| 0
| 3
|-
| PB
| 1
| 5
|-
| PC
| 2
| 6
|}

Considerando que una unidad de tiempo es de 50 ms, PA cada unidad de tiempo pasa a estado bloqueante por dos unidades y PC cada dos unidades de tiempo pasa a bloqueante una unidad, catalogue los procesos A,B y C según su comportamiento (en base a la clasificación de tipos de procesos vista en clase). (''[[Solución de los ejercicios de procesos#Ejercicio 1|Ver solución]]'')

== Ejercicio 2 ==
''[Este ejercicio fue parte del Primer Control de Evaluación Contínua en el curso 2011/12, del 8 de Noviembre de 2011]''

Definición de hilo y sus propiedades. Ventajas del uso de hilos.(''[[Solución de los ejercicios de procesos#Ejercicio 2|Ver solución]]'')

Comportamiento de los procesos

2012-01-28T15:32:03Z

Migoligon: /* Ejemplo */ reordenar contenido

= Tipos de procesos =

Un proceso, según su comportamiento, se puede catalogar en dos tipos:

* '''Procesos interactivos''': Son procesos cuyo comportamiento está limitado por operaciones de Entrada/Salida (I/O-bounded, en inglés). Este tipo de proceso realiza operaciones de Entrada/Salida con frecuencia. Por tanto, el proceso suele pasar a estado bloqueado al poco tiempo de estar asignado al procesador. Un ejemplo de este tipo de proceso es un editor de texto que solicita datos del teclado de manera continuada.
* '''Procesos por lotes''': Son procesos cuyo comportamiento está limitado por el procesador (processor-bounded, en inglés). Un ejemplo es un conversor de formato de vídeo MPG, este proceso ejecuta código de manera continuada hasta que el planificador decida retirarle el procesador. Por oposición, un ''proceso por lotes'' es un ''proceso no interactivo''.

Esta categorización debe entenderse como gradual, es decir, un proceso presenta un comportamiento interactivo en mayor o menor grado, o incluso su comportamiento puede variar a lo largo del tiempo, presentando un comportamiento interactivo inicialmente para, posteriormente, adoptar un comportamiento no interactivo.

[[Archivo:Procesos.jpg]]

En este ejemplo, podemos decir que el proceso Pa muestra un comportamiento '''interactivo''', ya que bloquea mucho, mientras que el proceso Pb muestra es un proceso '''por lotes''', ya que emplea el procesador hasta que el planificador se lo retira.

Planificador de procesos

2012-01-28T15:30:58Z

Migoligon: /* Ejemplo */ reordenar contenido

= ¿Qué es el planificador de procesos? =

El planificador de procesos (''process scheduler'', en inglés) es la parte del sistema operativo que se encarga de seleccionar a qué proceso se asigna el recurso procesador y durante cuánto tiempo.

= ¿Qué funciones tiene el planificador de procesos? =

El planificador de procesos tiene como funciones principales:

* Llevar el control del estado de cada proceso.
* Decidir qué proceso usará el procesador y durante cuanto tiempo, para ello empleará un cierto criterio en base al cual tomará las decisiones. Si implementa multiprogramación, deberá emplear un criterio que evite que un proceso monopolice el procesador.
* Asignar el procesador al proceso, restableciendo el contexto de la ejecución del proceso por donde fuere. El contexto de la ejecución se encuentra almacenado en el PCB del proceso asignado.
* Retirar el procesador al proceso, salvando el contexto de la ejecución del proceso, para poder restablecerlo posteriormente una vez que vuelva a ser asignado. El contexto de la ejecución se almacenará en el PCB del proceso retirado.

El planificador de procesos es software, por tanto, requiere emplear el recurso procesador para ejecutar su código.

= Ejemplo =

Para la siguiente configuración de procesos:

* Proceso Pa: Llega en el instante de tiempo 0. Realiza una llamada al sistema bloqueante cada 1 unidad de tiempo, la operación bloqueante se resuelve tras 2 unidades de tiempo. Para finalizar su ejecución requiere 4 unidades de ejecución.
* Proceso Pb: Llega en el instante de tiempo 1. Para finalizar su ejecución requiere 4 unidades de ejecución.
* Suponga que el proceso Pa tiene mayor prioridad que el proceso Pb, por tanto, el planificador debe de dejar paso al proceso Pa siempre que éste esté en estado preparado.

La evolución de la asignación del procesador que realizaría el planificador es la siguiente:

[[Archivo:Procesos.jpg]]

Multiprogramación

2012-01-28T14:44:41Z

Migoligon: He cambiado el modo texto por el modo svg.

La multiprogramación es una técnica de multiplexación que permite la ejecución simultánea de múltiples procesos en un único procesador. En realidad, esta técnica produce una ilusión de paralelismo, de manera que parece que todos los procesos se están ejecutando a la vez. Sin embargo, hay un único proceso ejecutándose en el procesador a la vez.

Un método para la multiprogramación es el Foreground/Background (o ejecución jerarquizada) (usado en sistemas por tandas, nunca en interactivos), en él hay un proceso prioritario (el foreground (FG)) que se ejecuta con preferencia de todos los demás, cuando este proceso solicita una operación L/E, mientras el s.o. la realiza, el proceso FG estará bloqueado por esta operación y le cede el control al proceso background 1 (BG), y si éste realiza una operación L/E, al BG2,… Cuando uno de los procesos bloqueados se desbloquea, recibe el control del procesador. Para que este método funcione de forma óptima la mejor forma es colocar los procesos ordenados de mayor a menor cantidad de operaciones L/E.

El siguiente diagrama de ejemplo representa el uso del procesador por tres procesos:

[[Archivo:Uso_del_procesador_general.svg]]

Como se puede observar en el ejemplo anterior, los procesos alternan periodos en los que progresan en su actividad, cuando están asignados al procesador, con periodos de inactividad, en los que no progresan en absoluto.

Si los periodos de inactividad son los suficientemente pequeños como para que el usuario del sistema operativo no los note, que en práctica se traduce a periodos de inactividad de menos de 100ms, el efecto causado es una ilusión de paralelismo. En caso contrario dará una sensación de que se producen "saltos".

El [[planificador de procesos|planificador de procesos]] es la parte del sistema operativo que se encarga de decidir qué proceso emplea el procesador en cada instante, por tanto, es el encargado de implementar la multiprogramación.

Archivo:Uso del procesador general.svg

2012-01-28T14:42:20Z

Migoligon:

Solución de los ejercicios de fundamentos

2012-01-28T13:35:49Z

Migoligon: /* Ejercicio 1 */ responder a la pregunta y darle formato

== Ejercicio 1 ==

Se puede responder a esta pregunta con el contenido de [[Modelos_de_Diseño_de_Sistemas_Operativos|este artículo]]. --[[Usuario:Pneira|Pneira]] 17:05 1 dic 2011 (UTC)

*Monolíticos: son núcleos de '''gran tamaño''' (muchas líneas de código) con un '''alto número de funcionalidades'''.

*Micronúcleos: son núcleos de '''pequeño tamañ'''o que fueron compilados sólo con las '''necesidades más básicas''' del sistema operativo

== Ejercicio 2 ==

Se puede responder a esta pregunta con el contenido de [[Componentes básicos de un sistema operativo|este artículo]]. --[[Usuario:Pneira|Pneira]] 17:05 1 dic 2011 (UTC)

Solución de los ejercicios de fundamentos

2012-01-28T13:29:01Z

Migoligon: /* Ejercicio 1 */ responder a la pregunta.

== Ejercicio 1 ==

Se puede responder a esta pregunta con el contenido de [[Modelos_de_Diseño_de_Sistemas_Operativos|este artículo]]. --[[Usuario:Pneira|Pneira]] 17:05 1 dic 2011 (UTC)

Monolíticos: son núcleos de gran tamaño (muchas líneas de código) con un alto número de funcionalidades.
Micronúcleos: son núcleos de pequeño tamaño que fueron compilados sólo con las necesidades más básicas del sistema operativo

== Ejercicio 2 ==

Se puede responder a esta pregunta con el contenido de [[Componentes básicos de un sistema operativo|este artículo]]. --[[Usuario:Pneira|Pneira]] 17:05 1 dic 2011 (UTC)

Llamadas al sistema

2012-01-28T13:04:19Z

Migoligon: /* 2.4. Llamadas al sistema */ faltaba contenido que tenia yo en los apuntes :s no se a donde habrá ido a parar.

= 2.4. Llamadas al sistema =

== Definición ==

Una llamada al sistema es el mecanismo que puede emplear un proceso para solicitar un cierto servicio al sistema operativo. Todo sistema operativo ofrece un conjunto de llamadas al sistema que viene determinado por una cierta API. En el caso de Linux, su version 3.0, ofrece un total de 345 llamadas al sistema. Toda llamada al sistema se identifica de manera unívoca mediante un valor numérico que debe permanecer el mismo a lo largo de la vida del sistema operativo para evitar que se rompa la compatibilidad hacia atrás.

Algunos ejemplos de llamadas al sistema son las siguientes:

* '''time''', que permite obtener la fecha y hora del sistema.
* '''write''', que se emplea para escribir un dato en un cierto dispositivo de salida, tales como una pantalla o un disco magnético.
* '''read''', que es usada para leer de un dispositivo de entrada, tales como un teclado o un disco magnético.

=== Api ===

Cada sistema operativo implementa su propia API, por eso normalmente un programa diseñado para un cierto sistema operativo no funciona en otro sistema operativo diferente. No obstante, existen APIs estandarizadas, como [http://es.wikipedia.org/wiki/POSIX POSIX], que tienden a ser implementadas por los fabricantes de sistemas operativos.

=== Compatibilidad de Apis ===

La interfaz de la llamada al sistema ha de ser estable a lo largo del tiempo. Además las llamadas en desuso u obsoletas deben permanecer para asegurar el funcionamiento de programas antiguos.

== Ejemplo de llamada al sistema ==

El siguiente ejemplo muestra el código en ensamblador de x86 para invocar a la llamada al sistema '''write''' que permite escribir un dato en cualquier dispositivo. En concreto, se va a escribir una cadena por el dispositivo de salida '''pantalla''', que se identifica mediante el descriptor de fichero número 1.

<source lang="asm">
section .text
global _start
_start:
mov eax, 4 ;cargamos el número de la llamada al sistema en el regitro eax
mov ebx, 1 ;cargamos el descriptor de fichero sobre el que queremos escribir
mov ecx, string ;cargamos en ecx la dirección de la cadena a imprimir
mov edx, lenght ;cargamos en edx el tamaño de la cadena a imprimir
int 80h ;se invoca al de

mov eax, 1
mov ebx, 0
int 80h

section .data
string: db "Hola Mundo", 0x0A
lenght: equ 13
</source>

La instrucción ''int'' forma parte del conjunto de instrucciones de procesadores x86. Esta instrucción emite una interrupción por software cuyo tratamiento es realizado por una rutina. En el caso de las llamadas al sistema, la rutina que se encarga del tratamiento de la interrupción por software número 80 es el ''dispatcher''.

== El ''dispatcher'' ==

El dispatcher, que forma parte del SO, se ejecuta cuando se invoca una llamada al sistema.
Cuando un proceso hace una llamada al sistema, el dispatcher, se encarga de invocar la llamada que el proceso ha solicitado.

En el caso de x86, el dispatcher consulta el registro eax e invoca a la llamada al sistema identificada con dicha numeración.

== El punto de entrada ==

Es la posición de memoria desde la cual es posible solicitarle servicios al sistema operativo. Normalmente hay un único punto de entrada.
En algunos SO se realiza mediante llamadas a subprogramas. La dirección de memoria del punto de entrada puede cambiar si se modifica el SO. En algunos SO éste problema lo solucionan usando una dirección fija, mientras en otros han preferido usar una referencia a dicha dirección

Llamadas al sistema

2012-01-28T12:51:12Z

Migoligon: /* El dispatcher */ reestructurar la frase para que sea más sencilla de entender.

= 2.4. Llamadas al sistema =

== Definición ==

Una llamada al sistema es el mecanismo que puede emplear un proceso para solicitar un cierto servicio al sistema operativo. Todo sistema operativo ofrece un conjunto de llamadas al sistema que viene determinado por una cierta API. En el caso de Linux, su version 3.0, ofrece un total de 345 llamadas al sistema. Toda llamada al sistema se identifica de manera unívoca mediante un valor numérico que debe permanecer el mismo a lo largo de la vida del sistema operativo para evitar que se rompa la compatibilidad hacia atrás.

Algunos ejemplos de llamadas al sistema son las siguientes:

* '''time''', que permite obtener la fecha y hora del sistema.
* '''write''', que se emplea para escribir un dato en un cierto dispositivo de salida, tales como una pantalla o un disco magnético.
* '''read''', que es usada para leer de un dispositivo de entrada, tales como un teclado o un disco magnético.

Cada sistema operativo implementa su propia API, por eso normalmente un programa diseñado para un cierto sistema operativo no funciona en otro sistema operativo diferente. No obstante, existen APIs estandarizadas, como [http://es.wikipedia.org/wiki/POSIX POSIX], que tienden a ser implementadas por los fabricantes de sistemas operativos.

== Ejemplo de llamada al sistema ==

El siguiente ejemplo muestra el código en ensamblador de x86 para invocar a la llamada al sistema '''write''' que permite escribir un dato en cualquier dispositivo. En concreto, se va a escribir una cadena por el dispositivo de salida '''pantalla''', que se identifica mediante el descriptor de fichero número 1.

<source lang="asm">
section .text
global _start
_start:
mov eax, 4 ;cargamos el número de la llamada al sistema en el regitro eax
mov ebx, 1 ;cargamos el descriptor de fichero sobre el que queremos escribir
mov ecx, string ;cargamos en ecx la dirección de la cadena a imprimir
mov edx, lenght ;cargamos en edx el tamaño de la cadena a imprimir
int 80h ;se invoca al de

mov eax, 1
mov ebx, 0
int 80h

section .data
string: db "Hola Mundo", 0x0A
lenght: equ 13
</source>

La instrucción ''int'' forma parte del conjunto de instrucciones de procesadores x86. Esta instrucción emite una interrupción por software cuyo tratamiento es realizado por una rutina. En el caso de las llamadas al sistema, la rutina que se encarga del tratamiento de la interrupción por software número 80 es el ''dispatcher''.

== El ''dispatcher'' ==

El dispatcher, que forma parte del SO, se ejecuta cuando se invoca una llamada al sistema.
Cuando un proceso hace una llamada al sistema, el dispatcher, se encarga de invocar la llamada que el proceso ha solicitado.

En el caso de x86, el dispatcher consulta el registro eax e invoca a la llamada al sistema identificada con dicha numeración.

Página con listado de personas que han contribuido

2012-01-28T11:54:43Z

Migoligon:

A continuación, la lista de usuarios/as de la Universidad de Sevilla que han contribuido a la wiki. Si ponéis tu usuario/a estás solicitando al profesor que evalúe tus contribuciones a la wiki para la subida de notas de hasta 2 puntos posible:

* luigarhor
* rafperper
* sergaralo
* josalgrod1
* felgaroje
* luimunlei
* [https://1984.lsi.us.es/wiki-ssoo/index.php/Usuario:Lorruimor Lorruimor]
* albsolnog
* framorexp
* javgarang
* FerGuaTol
* jesgonbel
* fraperdom
* antdomflo
* antmorzam
* migoligon

Diseño modular E/S

2012-01-21T01:47:58Z

Migoligon: Pasar imagn ascii a svg

La idea clave de esta arquitectura en capas es hacer independiente al proceso del dispositivo. Por lo general, en ingeniería del software, la independencia del proveedor es una propiedad muy deseable.

[[Archivo:disenomodular.svg]]

Esta abstracción permite:

* Hacer a los procesos independientes de los dispositivos de E/S. Esto es deseable en cuanto a que el fabricante del dispositivo podría dejar de fabricar el dispositivo, por tanto, el proceso tendría que ser reescrito para soportar el nuevo dispositivo. De igual manera, si el dispositivo para el que está diseñado el proceso que conoce los detalles de bajo nivel no está disponible en el sistema, nuestro proceso quedaría inservible.
* Forzar a que un proceso tenga que pasar por el sistema operativo, que es quien garantiza que el reparto de recursos es equitativo. Si un proceso dispone de acceso directo a un dispositivo, podría adoptar un comportamiento ''abusón'' de manera que no permitiera a otros procesos emplearlo.

'''Nota''': el SSI es una subrutina de manejo de interrupciones.

Archivo:Disenomodular.svg

2012-01-21T01:45:54Z

Migoligon:

Estructura típica de dispositivo E/S

2012-01-20T20:41:38Z

Migoligon: He cambiado el modo texto por el modo svg, tras muchos intentos por hacer un svg bien.

En general, la estructura típica de un dispositivo de entrada/salida está dividida en tres partes:

* '''Adaptador de Entrada/Salida del ordenador, o interfaz del bus:''' Se encarga de traducir las señales al dialecto empleado por el bus del ordenador. Algunos ejemplos de interfaces de este tipo son los buses PCI, PCMCIA, USB, PCI-express o SATA entre muchos otros.
* '''Adaptador de Entrada/Salida del dispositivo, o interfaz del dispositivo:''' Se encarga de traducir las señales al dialecto empleado por el dispositivo.
* '''Control del dispositivo, o puerto de lectura/escritura:''' Ofrece una interfaz que es empleada por el gestor de dispositivos para gobernar el dispositivo, que dispone de:
**Registros de órdenes
**Registros de estado
**Registros de lectura/escritura, o alternativamente una pequeña memoria propia.

Cuanto más elaborado sea el puerto de lectura/escritura, mayor rendimiento se puede llegar a alcanzar, puesto que el gestor de dispositivo será más sencillo (y eso implica menor número de instrucciones a ejecutar en el gestor de dispositivo).

La conexión existente entre el procesador y el dispositivo de E/S queda resumida de la siguiente manera:

[[Archivo:Dispositivos ES.svg|Estructura del dispositivo]]

= Gestor de dispositivos =

El gestor de dispositivo, popularmente conocido por la palabra inglesa ''driver'', es la parte del sistema operativo que se encarga de gobernar un cierto dispositivo o una familia de dispositivos de naturaleza similar. El gestor de dispositivo se trata de una pieza de software que conoce los detalles de bajo nivel del dispositivo. De esta manera el driver hace uso del conjunto de instrucciones que ofrece el puerto de E/S, los registros de estado y de lectura
y escritura, para gobernar el dispositivo. Si el fabricante del dispositivo no ofrece un ''driver'' para un cierto sistema operativo, el dispositivo y los recursos que ofrece no puede ser gestionado por el sistema operativo. Por lo general el fabricante de un dispositivo desarrolla el gestor de dispositivo para los sistemas operativos mayoritarios (i.e. Windows y Linux) para asegurar que su dispositivo alcanza la mayor cuota de usuarios posibles.

Los gestores de dispositivos representan en torno al 70% de los sistemas operativos<ref>Construction of a Highly Dependable Operating System, Proc. 6th European Dependable Computing Conference (EDCC-6), pp. 3-12, Oct. 2006</ref>. Por lo general, en los sistemas operativos monolíticos se ejecutan en el espacio del núcleo del sistema operativo por razones de rendimiento. Por tanto, se ejecutan en modo privilegiado, así un error de programación en un ''driver'' lleve a un cuelgue completo del sistema con casi total seguridad. Se estima que en torno al 85% de cuelgues de Microsoft Windows XP <ref>Recovering Device Drivers, Proc. OSDI '04, pp. 1-16, 2004</ref>se debe a errores de programación en ''drivers''.

No obstante, en sistemas operativos convencionales como Windows, Linux y Mac, existen mecanismos que permiten ejecutar ''drivers'' como procesos de usuario, tal y como sucede en sistemas operativo de tipo micronúcleo. De esta manera, un error de programación no produce el cuelgue del sistema completo. No obstante, dichos gestores de dispositivos se limitan a dispositivos particularmente lentos en los que la tasa de transferencia de datos es baja y los tiempos de respuesta del dispositivo son altos, por ejemplo, los gestores de dispositivos para lectores de tarjetas inteligentes (smartcards, lo que incluye las tarjetas SIM que se emplean en telefonía móvil) en Linux funcionan en espacio de usuario.

==Notes==
<references/>

Archivo:Dispositivos ES.svg

2012-01-20T20:39:39Z

Migoligon: subió una nueva versión de «Archivo:Dispositivos ES.svg»: Es mejor si lo reviso y pongo el dibujo según los apuntes y no según yo me quiera inventar. Ahora está bien el dibujo hecho según lo que pone en la wiki.