Wiki de Sistemas Operativos - Contribuciones del usuario [es]

Página Principal

2017-01-26T09:27:41Z

Enrloport: /* Novedades y noticias */

Bienvenido al wiki de la asignatura de Sistemas Operativos del departamento de Lenguajes y Sistemas Informáticos de la Universidad de Sevilla. ¡Contribuye!

= Novedades y noticias =

* '''Recuperación de clase en H0.13 a las 12h30, viernes 13 de enero.'''

* Disponible notas del primer control de evaluación continua [https://1984.lsi.us.es/wiki-ssoo/images/f/f3/Notas-ssoo.pdf]

* Disponible notas del primer control de evaluación continua [https://1984.lsi.us.es/wiki-ssoo/images/d/de/C2.pdf]

* Disponible notas del primer control de evaluación continua [https://1984.lsi.us.es/~pablo/notas-ssoo-gis1.pdf]

* Disponible notas del primer control de evaluación continua [https://1984.lsi.us.es/~pablo/notas-ssoo-gis1-c4.pdf]

* Contribuidores a la wiki, por favor, incluyan su nombre de usuario, sus apellidos y nombre aquí debajo para valorar la subida de nota. Igualmente los que hayan realizados tareas con el xv6 o similar.

Gutiérrez Pérez, Juan gutpeju Tipo de trabajo: mejoras en la wiki

Castaño del Castillo, Carlos, carcasdel1. Tipo de trabajo: añadir teoría en la wiki, añadir ejercicios dados en clase y corregir multitud de ejercicios de la wiki de los temas dados.

Luigilgue, Luis Gil Guerrero: Corrección de ejercicios y algunos videos.

Antsegjim, Segura Jiménez, Antonio - Tipo de trabajo: Emulación de XV6 y añadir el comando pwd al sistema operativo.

enrloport, López Ortiz, Enrique - Tipo de Trabajo: Emulación de comando pwd en xv6 (verificado por pneira).

= Unidades didácticas =

A continuación encontrarás las unidades didácticas que forman parte de la asignatura.

== Introducción a los Sistemas Operativos ==

* 1.1. [[Qué es un Sistema operativo|Qué es un Sistema Operativo]]
* 1.2. [[Introducción histórica|Breve introducción histórica a los Sistemas Operativos]]
* 1.3. [[Tipos de Sistemas Operativos|Tipos de Sistemas Operativos]]

== Fundamentos de Sistemas Operativos ==

* 2.1. [[Organización básica de un ordenador]]
* 2.2. [[Modos de operación de la CPU|Modos de operación de la CPU]]
* 2.3. [[Interrupciones y excepciones|Interrupciones y excepciones]]
* 2.4. [[Arranque del sistema|Arranque del sistema]]
* 2.5. [[Componentes básicos de un sistema operativo|Componentes básicos de un sistema operativo]]
* 2.6. [[Conceptos básicos|Conceptos básicos]]
* 2.7. [[Llamadas al sistema|Llamadas al sistema]]
* 2.8. [[Ejercicios fundamentos Sistemas Operativos|Ejercicios]]

== Modelos de diseño de Sistemas Operativos ==

* 3.1. [[Modelos de Diseño de Sistemas Operativos|Modelos de diseño de sistemas operativos]]
* 3.2. [[Virtualización]]
* 3.3. [[Ejercicios 3|Ejercicios]]

== Procesos ==
* 4.1. [[Multiprogramación|La multiprogramación]]
* 4.2. [[Estados de los procesos|Estados de los procesos]]
* 4.3. [[Planificador de procesos|El planificador de procesos]]
* 4.4. [[Comportamiento de los procesos|El comportamiento de los procesos según el planificador]]
* 4.5. [[Bloque de control de procesos|El bloque de control del proceso]]
* 4.6. [[Conmutación de procesos|La conmutación de procesos]]
* 4.7. [[Hilos|Hilos]]
* 4.8. [[Ejercicios Procesos|Ejercicios]]

== Planificación de Procesos ==
* 5.1 [[Planificación de procesos|La planificación de procesos]]
* 5.2 [[Índices de evaluación|Índices de evaluación de la planificación de procesos]]
* 5.3 [[Criterios de planificación|Criterios de planificación]]
* 5.4 [[Planificadores de sistemas operativos existentes|Planificadores de sistemas operativos existentes]]
* 5.5 [[Planificación de procesos de tiempo real|La planificación de procesos de tiempo real]]
* 5.6 [[Planificación en sistemas multiprocesadores|La planificación de procesos en sistemas multiprocesadores]]
* 5.7 [[Ejercicios otros aspectos de la planificación|Ejercicios]]
* 5.8 [[Ejercicios planificación de procesos|Ejercicios]]
* 5.9 [[Ejercicios_simples_de_planificación_de_procesos|Ejercicios]]

== Concurrencia de procesos ==

* 6.1 [[Concurrencia de procesos|Concurrencia de procesos]]
* 6.2 [[Mecanismos de sincronización|Control optimista y pesimista de la concurrencia]]
* 6.3 [[Cerrojos|Cerrojos]]
* 6.4 [[Ejercicio de concurrencia de procesos|Ejercicios]]
* 6.5 [[Semáforos|Semáforos]]
* 6.6 [[Monitores|Monitores]]
* 6.7 [[Mensajería|Mensajería]]
* 6.8 [[Ejercicios sincronización y comunicación|Ejercicios]]

== Interbloqueo ==

* 7.1 [[Definición de interbloqueo|Definición]]
* 7.2 [[Condiciones para el interbloqueo y estrategias de resolución|Modelado y Estrategias]]
* 7.3 [[Algoritmo para averiguar interbloqueo|Algoritmo del banquero]]
* 7.4 [[Ejercicios]]

== Administración de memoria ==

* 8.1 [[Introducción|Introducción]]
* 8.2 [[SO multiprogramables con particiones variables|SO multiprogramables con particiones variables]]
* 8.3 [[Segmentación|Segmentación]]
* 8.4 [[Paginación|Paginación]]
* 8.5 [[Sistema combinado|Sistema combinado]]
* 8.6 [[Ejercicios administración de memoria contigua|Ejercicios (Administración de memoria contigua)]]
* 8.7 [[Ejemplo de segmentación, paginación y combinado|Ejercicios (Segmentación, paginación y sistemas combinados)]]

== Memoria virtual ==

* 9.1 [[Memoria Virtual|Introducción]]
* 9.2 [[Criterios de reemplazo|Criterios de reemplazo]]
* 9.3 [[Memoria virtual con multiprogramacion|Otros aspectos relacionados con la memoria virtual]]
* 9.4 [[Ejercicios memoria virtual|Ejercicios]]

== Entrada/Salida ==

* 10.1 [[EstructuraES|Estructura dispositivo E/S]]
* 10.2 [[GestionES|Modos de gestionar dispositivos E/S]]
* 10.3 [[Diseño modular E/S|Diseño modular E/S]]
* 10.4 [[Ejercicios de Entrada/Salida|Ejercicios]]

== Gestión L/E ==

* 11.1 [[Discos Magnéticos|Discos Magnéticos]]
* 11.2 [[Mejoras de tiempos de desplazamiento|Mejoras de tiempos de desplazamiento]]
* 11.3 [[Mejoras en la demora de rotación|Mejoras en la demora de rotación]]
* 11.4 [[Tipos de errores en discos magnéticos|Tipos de errores en discos magnéticos]]
* 11.5 [[Ejercicios Gestión L/E|Ejercicios]]

== Administración de archivos ==

* 12.1 [[Introducción en la administración de archivos|Introducción en la administración de archivos]]
* 12.2 [[FAT|FAT]]
* 12.3 [[EXT2 |EXT2]]
* 12.4 [[Ejercicios Administración Ficheros|Ejercicios]]

== Anexo ==

Esta sección contiene información interesante pero que no pertenece al temario de la asignatura.

* Todo lo que siempre has querido saber sobre el protocolo SSH está [[SSH|aquí]].
* Instrucciones para emular BATHOS usando QEMU [[bathos_QEMU|aquí]].
* Instrucciones para emular XV6 usando QEMU [[xv6|aquí]].

Discos Magnéticos

2017-01-10T16:52:51Z

Enrloport: /* Partes del disco magnético */

== Arquitectura de los discos magnéticos ==

Los discos magnéticos están formados por varios discos (desde 2 hasta 7) de material magnético montados sobre el mismo eje, los cuales se mantienen girando a una velocidad constante. Estos discos están recorridos, cada uno, por 2 cabezales magnéticos que no llegan a tocar el disco (están separados por unos 3 nanómetros debido a una delgada capa de aire formada por la rotación del disco, de hecho si lo tocan se produce un error conocido como aterrizaje del cabezal) y que leen y escriben datos en el disco creando puntos de campo magnético.

En esta imagen se muestran los componentes de un disco duro magnético:

[[Archivo:componentes_HD_comentados.png]]

= Partes del disco magnético =

La superficie del disco magnético se divide en la siguientes partes:

* Pista (''track'', en inglés): Zona a la que accede el cabezal si este se queda fijo en una posición y el disco sigue girando. Si el cabezal se tratara de un lápiz, la pista sería la zona que el cabezal dibuja sobre el disco (que se trataría de una circunferencia). Hay que tener en cuenta que las pistas más cercanas al centro del disco son de menor tamaño al tener menor radio la circunferencia.
* Sector: Es una subdivisión de una pista (track) en un disco magnético. Cada sector almacena una cantidad fija de datos.
* Cilindro: Conjunto de pistas a las que el conjunto de cabezales pueden acceder desde una posición. Un cilindro está compuesto por un conjunto de sectores.

[[Archivo:cilindro.jpg]][[Archivo:Estructura_disco.png|Estructura de un disco óptico|right]]

= Prestaciones de un disco duro magnético =

Las prestaciones de un disco se pueden medir mediante los siguientes indicadores:

* Capacidad, cantidad de unidades de información que se pueden almacenar en el disco.
* Revoluciones por minuto (RPM), velocidad constante a la que gira el disco magnético.
* Tiempo de arranque del motor, se trata del tiempo que tarda el motor en hacer que el disco comience a girar a velocidad constante.
* Tiempo de accesos, tanto para operaciones de lectura como escritura:
** Tiempo de búsqueda, se trata del tiempo que tarda el cabezal en desplazarse de una pista a otra.
** Demora de rotación, se trata del tiempo que tarda en pasar un sector por delante del cabezal.
** Tiempo de transmisión, se trata del tiempo que toma la transferencia de datos del dispositivo al gestor de dispositivo.

= Recursos multimedia =
Funcionamiento electromecánico de un disco duro:
http://www.youtube.com/watch?v=Wiy_eHdj8kg

Discos Magnéticos

2017-01-10T16:52:27Z

Enrloport: /* Partes del disco magnético */

== Arquitectura de los discos magnéticos ==

Los discos magnéticos están formados por varios discos (desde 2 hasta 7) de material magnético montados sobre el mismo eje, los cuales se mantienen girando a una velocidad constante. Estos discos están recorridos, cada uno, por 2 cabezales magnéticos que no llegan a tocar el disco (están separados por unos 3 nanómetros debido a una delgada capa de aire formada por la rotación del disco, de hecho si lo tocan se produce un error conocido como aterrizaje del cabezal) y que leen y escriben datos en el disco creando puntos de campo magnético.

En esta imagen se muestran los componentes de un disco duro magnético:

[[Archivo:componentes_HD_comentados.png]]

= Partes del disco magnético =

La superficie del disco magnético se divide en la siguientes partes:

* Pista (''track'', en inglés): Zona a la que accede el cabezal si este se queda fijo en una posición y el disco sigue girando. Si el cabezal se tratara de un lápiz, la pista sería la zona que el cabezal dibuja sobre el disco (que se trataría de una circunferencia). Hay que tener en cuenta que las pistas más cercanas al centro del disco son de menor tamaño al tener menor radio la circunferencia.
* Sector: Es una subdivisión de una pista (track) en un disco magnético. Cada sector almacena una cantidad fija de datos.
* Cilindro: Conjunto de pistas a los que el conjunto de cabezales pueden acceder desde una posición. Un cilindro está compuesto por un conjunto de sectores.

[[Archivo:cilindro.jpg]][[Archivo:Estructura_disco.png|Estructura de un disco óptico|right]]

= Prestaciones de un disco duro magnético =

Las prestaciones de un disco se pueden medir mediante los siguientes indicadores:

* Capacidad, cantidad de unidades de información que se pueden almacenar en el disco.
* Revoluciones por minuto (RPM), velocidad constante a la que gira el disco magnético.
* Tiempo de arranque del motor, se trata del tiempo que tarda el motor en hacer que el disco comience a girar a velocidad constante.
* Tiempo de accesos, tanto para operaciones de lectura como escritura:
** Tiempo de búsqueda, se trata del tiempo que tarda el cabezal en desplazarse de una pista a otra.
** Demora de rotación, se trata del tiempo que tarda en pasar un sector por delante del cabezal.
** Tiempo de transmisión, se trata del tiempo que toma la transferencia de datos del dispositivo al gestor de dispositivo.

= Recursos multimedia =
Funcionamiento electromecánico de un disco duro:
http://www.youtube.com/watch?v=Wiy_eHdj8kg

Criterios de planificación

2016-12-04T11:54:58Z

Enrloport: /* Por prioridades */

=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__|_14_|_3__| z = índice de penalización
_z__|_1__|_8/5|_1__|14/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 un í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.

Hay que tener en cuenta que:
* Cuando un proceso consume su quantum pasa al final de la cola de preparados.
* Un proceso en estado bloqueado se inserta en la cola de preparados una vez que pasa el tiempo de bloqueo.

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|

5.4 [[Planificadores_de_sistemas_operativos_existentes | Planificadores de sistemas operativos existentes]]

Algoritmo para averiguar interbloqueo

2016-12-04T09:53:56Z

Enrloport: /* Algoritmo en Java */

== Algoritmo del Banquero ==

'''Introducción:'''

Este algoritmo recibe el nombre de banquero porque su funcionamiento es parecido a la gestión que hacen los bancos con las cuentas de crédito.
Necesita conocer de antemano las necesidades máximas de recursos por parte de cada proceso, esto es poco realista. Además, supone que cuando un proceso ha conseguido todos los recursos que necesita, los libera.

Para entenderlo un poco mejor hagamos la similitud con un banco:
Un banquero (s.o.) dispone de unos fondos (recursos) y tiene unos clientes (procesos). Cada cliente dispone de un crédito que corresponde al máximo que el banquero le prestará. El cliente irá solicitando fondos de ese crédito conforme los necesite. Si el banquero tuviese
fondos suficientes para prestar el máximo a cada cliente, no habría inconvenientes. Sin embargo, esto no es así, los recursos del banquero
son limitados, por lo que si todos reclaman todo su crédito no podrá satisfacerlos simultáneamente. Por lo tanto, la solución es que el
banquero gestione sus fondos de manera que todos los clientes puedan llegar al máximo en algún momento, aunque no lo hagan todos al mismo tiempo.

Estado seguro: El estado del sistema es seguro si existe una secuencia de asignaciones y liberaciones de recursos que permita a todos los procesos alcanzar en algún momento sus necesidades máximas de recursos.

La idea genérica del algoritmo es:

1. Buscar un proceso cuya suma recAsig + recDisp >= recMax
2. Suponemos que se asignan dichos recursos y el proceso termina su ejecución.
Sumamos sus recursos al vector recDisp y añadimos el proceso a la lista de finalizados.
3. Repetir primer paso hasta terminar todos los procesos (siendo un estado estable)
o bien hasta el punto en el que no sea posible ninguna asignación de recursos,
existiendo pues interbloqueo.

Ejemplo:

Proceso | Asignados | Maximos | Disponibles
| A B C D E | A B C D E | A B C D E
__________|_____________|___________|_______________
P0 | 1 0 2 1 1 | 1 2 2 1 2 | 0 0 2 1 1 //Recursos Disponibles Iniciales
P1 | 2 0 1 1 0 | 2 2 2 1 0 | 1 1 3 2 1 //P3 finalizado
P2 | 1 1 0 1 0 | 2 1 3 1 0 | 2 2 3 3 1 //P2 finalizado
P3 | 1 1 1 1 0 | 1 1 2 2 1 | 3 2 5 4 2 //P0 finalizado
//P1 finalizado
Pasos:
1. El primer proceso que cumple el paso 1 del algoritmo en esta tabla es P3:
[1 1 1 1 0]+[0 0 2 1 1] >= [1 1 2 2 1]
Lo consideramos terminado y añadimos sus recursos a los disponibles:
[1 1 1 1 0]+[0 0 2 1 1] = [1 1 3 2 1]
2. Volvemos a iterar desde P0. El siguiente proceso que puede adquirir los recursos necesarios
es P2. Añadimos sus recursos a la lista de disponibles.
3. Ahora nos es posible terminar P0 y por último P1.
4. Hemos logrado terminar todos los procesos sin problemas.

== Algoritmo en C# ==

<source lang="csharp">
int nRecursos;
int nProcesos;
List<List<int>> asignados = new List<List<int>>();
List<List<int>> maximos = new List<List<int>>();
List<int> disponibles = new List<int>();

Random r = new Random();

//Generamos las matrices aleatoriamente
for (int j1 = 0; j1 < nRecursos;j1++)
{
disponibles.Add(r.Next(0, nRecursos));
}
for (int i = 0; i < nProcesos; i++)
{
asignados.Add(new List<int>());
maximos.Add(new List<int>());
for (int j = 0; j < nRecursos; j++)
{
asignados[i].Add(r.Next(0, nRecursos));
maximos[i].Add(r.Next(0, nRecursos));
}
}

bool aux = true;
for (int proc = 0; proc < nProcesos; proc++)
{
aux = true;
for (int recur = 0; recur < nRecursos; recur++)
{
// comprobamos que haya recursos suficientes
aux = (maximos[proc][recur] - asignados[proc][recur] - disponibles[recur]) <= 0;
if (!aux)
{
break;
}
}
if (aux)
{
añadirYeliminar(ref disponibles, ref asignados, proc);
maximos.RemoveAt(proc);
nProcesos--;
proc = -1;
if (nProcesos == 0)
{
Console.WriteLine("Es estado seguro");
Console.ReadLine();
return;
}
}
}
Console.WriteLine("Es interbloqueo");
Console.ReadLine();

}

private static void añadirYeliminar(ref List<int> disponibles, ref List<List<int>> asignados, int proc)
{
for (int k = 0; k < asignados[proc].Count; k++)
{
disponibles[k] += asignados[proc][k];
}
asignados.RemoveAt(proc);
}
</source>

Faltaria solamente leer por consola el numero de procesos y de recursos que queremos testear, o introduccirlos manualmente

== Algoritmo en Python ==

<source lang="python">
def comprueba_configuracion(asignados, maximos, disponibles):
finalizados = []
i = 0
while(i < len(asignados)):
if not i in finalizados and puede_progresar(asignados[i], disponibles, maximos[i]):
print('Finaliza P%s\nDisponibles: %s' % (i,disponibles))
libera_recursos(asignados[i], disponibles)
finalizados.append(i) # Marca el proceso Pi como finalizado
i = 0
else:
i += 1

if(len(asignados) == len(finalizados)): # Si todos los procesos finalizan
print('\nEstado seguro para la configuracion de procesos-recursos dada')
else:
print('\nSe produce un interbloqueo')

# Incrementamos la lista de disponibles con los que tenia asignados
def libera_recursos(asignados, disponibles):
for i in range(len(disponibles)):
disponibles[i] += asignados[i]

# Devuelve True si el nº de elementos asignados mas los disponibles son mayores o iguales a los requeridos para continuar
def puede_progresar(asignados, disponibles, maximos):
resultado = True
for i in range(len(maximos)):
if(asignados[i] + disponibles[i] < maximos[i]):
resultado = False
break
return resultado

asignados = [
[1,0,2,1,1],
[2,0,1,1,0],
[1,1,0,1,0],
[1,1,1,1,0]
]
maximos = [
[1,2,2,1,2],
[2,2,2,1,0],
[2,1,3,1,0],
[1,1,2,2,1]
]
disponibles = [0,0,2,1,1]
</source>

Para este ejemplo (visto en clase) la salida sería:

<source lang="python">
>>> comprueba_configuracion(asignados, maximos, disponibles)
Finaliza P3
Disponibles: [0, 0, 2, 1, 1]
Finaliza P2
Disponibles: [1, 1, 3, 2, 1]
Finaliza P0
Disponibles: [2, 2, 3, 3, 1]
Finaliza P1
Disponibles: [3, 2, 5, 4, 2]

Estado seguro para la configuracion de procesos-recursos dada
</source>

== Algoritmo en Java ==
<source lang="java">
<pre>
public class Comprobaciones {

public static List<Proceso> devuelveLista(List<Proceso> asignados, List<Proceso> necesarios, Disponibles recursos){
List<Proceso> terminados = new ArrayList<Proceso>();
for(int i = 0; i < necesarios.size(); i++){
if(!(terminados.contains(asignados.get(i))) && ejecuta(asignados.get(i), necesarios.get(i), recursos)){
terminados.add(asignados.get(i));
System.out.println("Proceso " + asignados.get(i).getNombre() + " terminado");
for(int j = 0; j < recursos.getDisponibles().size(); j++){
recursos.setDisponible(recursos.getDisponibles().get(j) + asignados.get(i).getRecursosNecesarios().get(j), j);
}
System.out.println("Recursos disponibles: " + recursos.getDisponibles());
i = -1;
}

}
if(terminados.size() == asignados.size()){
System.out.println("Todos los procesos han sido ejecutados sin problemas.");
}
else{
System.out.println("Hay un interbloqueo, no se pueden seguir ejecutando procesos...");
}
return terminados;
}

public static Boolean ejecuta(Proceso asignados, Proceso necesarios, Disponibles disponibles){
// Devuelve True si tiene recursos suficientes...
Boolean ej = true;
for(int i = 0; i < necesarios.getRecursosNecesarios().size(); i++){
if((asignados.getRecursosNecesarios().get(i) + disponibles.getDisponibles().get(i)) < necesarios.getRecursosNecesarios().get(i)){
ej = false;
break;
}
}
return ej;
}

}
</pre>
</source>
<source lang="java">
<pre>
public static void main(String[] args) {

List<Proceso> asignados = creaAsignados();
List<Proceso> necesarios = creaNecesarios();
Disponibles disponibles = creaDisponibles();
Comprobaciones.devuelveLista(asignados, necesarios, disponibles);
}
</pre>
</source>
Resultado:
<pre>
Proceso P4 terminado
Recursos disponibles: [1, 1, 3, 2, 1]
Proceso P3 terminado
Recursos disponibles: [2, 2, 3, 3, 1]
Proceso P1 terminado
Recursos disponibles: [3, 2, 5, 4, 2]
Proceso P2 terminado
Recursos disponibles: [5, 2, 6, 5, 2]
Todos los procesos han sido ejecutados sin problemas.
</pre>
Nota: Las clases lo único que contienen son listas de enteros, y los procesos contienen además los nombres de los mismos.

7.4 [[Ejercicios | Ejercicios]]

Condiciones para el interbloqueo y estrategias de resolución

2016-12-04T09:52:33Z

Enrloport: /* Predicción */

= Condiciones para que se produzca interbloqueo =

Según [http://en.wikipedia.org/wiki/Edward_G._Coffman,_Jr. Coffman], para que se pueda producir un interbloqueo se tienen que dar las siguientes cuatro condiciones:

* '''Exclusión mutua''': cada recurso está asignado a un único proceso de manera exclusiva.
* '''Retención y espera''': los procesos que tienen, en un momento dado, recursos asignados con anterioridad, pueden solicitar nuevos recursos y esperar a que se le asignen sin liberar antes alguno de los recursos que ya tenía asignados.

* '''No apropiación''': los recursos otorgados con anterioridad no pueden ser forzados a dejar un proceso. El proceso que los posee debe liberarlos en forma explícita. Ni siquiera el sistema operativo puede expropiárselo.

* '''Espera circular''': debe existir una cadena circular de dos o más procesos, cada uno de los cuales espera un recurso poseído por el siguiente miembro de la cadena. Esta condición es una consecuencia potencial de las tres primeras, es decir, dado que se producen las tres primeras condiciones, puede ocurrir una secuencia de eventos que desemboque en un círculo vicioso de espera irresoluble.

Las tres primeras condiciones son necesarias, pero no suficientes para que exista interbloqueo. Sólo las cuatro condiciones en conjunto constituyen una condición necesaria y suficiente para el interbloqueo.

= Estrategias =

Existen diversas estrategias frente a los interbloqueos, que se pueden agrupar en:

* Omisión
* Detección y recuperación
* Prevención
* Predicción

Que se detallan a continuación.

== Omisión ==

Considera que la probabilidad de un interbloqueo es muy baja, de modo que se confía en que no se van a producir. Por sorprendente que parezca, los sistemas operativos modernos convencionales suelen aplicar esta estrategia. Por justificar la decisión de los fabricantes de sistemas operativos cabe incidir en que las estrategias de resolución y prevención de interbloqueos tienen un coste alto desde el punto de vista del consumo de recursos de procesamiento y memoria.

== Detección y Recuperación ==

Esta estrategia permite la detección de una situación de interbloqueo y su consiguiente resolución. De entre las medidas de detección consideramos las siguientes:

* ''Grafo de relación recursos-procesos'': Consiste en la representación gráfica de los recursos asignados a los procesos y los recursos que dichos procesos requieren para finalizar su ejecución. Esta técnica se basa en recorrer el grafo yendo de un nodo a otro, por lo que si se consigue volver al nodo de partida estaremos en un recorrido circular. Para que este tipo de error sea detectado usamos algoritmos de detección, se lanzan cuando se solicita un recurso ocupado, es decir, hay una nueva arista dentro de nuestro grafo y debemos comprobar que no da lugar a un recorrido cíclico.

Un ejemplo de grafo en el que se detecta un ciclo es el siguiente:

[[Archivo:deteccion_ciclo.png]]

* ''Matrices de relación recursos-procesos'': Consiste en la representación matricial de los recursos asignados a los procesos y los recursos que dichos procesos requieren para finalizar su ejecución. Se distinguen dos tipos, el '''método mediante matrices binarias de relación''', y el '''método de detección matricial''':

=== Matrices binarias de relación ===
Una matriz binaria de relación es aquella que representa una relación R entre dos conjuntos, en la cual el primero de estos dos tiene múltiples asignaciones a elementos del segundo.

El método consiste en, aplicando matrices binarias de relación, utilizar el cierre transitivo para determinar si algún proceso está relacionado consigo mismo a través de otros, señalando así la existencia de ciclos. El procedimiento sería:

1.- Formar la matriz de espera (W: P->R): Los procesos P están a la espera de recursos R.

2.- Formar la matriz de asignación (A: R->P): Los recursos R están asignados a procesos P.

3.- Formar la matriz de procesos a la espera de procesos (T: WxA): Producto cartesiano de ambas matrices.

4.- Hallar el cierre transitivo de la matriz T: Que se puede obtener, por ejemplo, aplicando el Algoritmo de Warshall (algoritmo de análisis sobre grafos para encontrar el camino mínimo entre todos los pares de vértices en una única ejecución). El algoritmo es el siguiente:

Warshall(T, n){
for (k=1 to n){
for (i=1 to n){
for (j=1 to n){
Tij = Tij ⋁ (Tik ⋀ Tkj)
}
}
}
}

Donde n es la dimensión de la matriz T

5.- Si hay procesos que tengan un 1 en la diagonal principal, forman parte de algún ciclo.

Se trata de un método fácil de implementar, ya que solo se realizan operaciones con matrices y bucles, algo muy sencillo para una máquina. Sim embargo, tiene dos inconvenientes:
* El número de operaciones a realizar es muy alto teniendo en cuenta el tamaño que pueden alcanzar las matrices de recursos
* Solo se puede usar cuando solo existe una instancia de cada recurso.

=== Detección matricial ===
Método matricial que trata aquellos casos en los que existen múltiples instancias de un mismo recurso. Aísla grupos de procesos que no pueden proseguir la ejecución porque no pueden ver satisfechas sus peticiones pendientes.
Usan un método iterativo que:

1.-Marca procesos cuyas peticiones puedan satisfacerse con el actual vector de recursos disponibles.

2.-Suma al vector de disponibles los recursos asignados a los procesos marcados.

3.-Si todos los procesos están marcados: no hay interbloqueo.

4.-Si en una iteración no se marcan procesos: los procesos que quedan están interbloqueados.

== Resolución de interbloqueo ==

Tras la detección de un interbloqueo, se pueden aplicar algunas de las siguientes estrategias para resolverlo:

* ''Eliminación'': El sistema operativo selecciona a uno de los procesos que forma parte del interbloqueo y elimina el ciclo acabando con la ejecución de dicho proceso, si no es suficiente se eliminarán procesos hasta que se rompa el ciclo. La selección del proceso se realiza en base a un cierto criterio, por ejemplo, aquel proceso que lleve menos tiempo en ejecución o aquel que sea más voraz consumiendo recursos.Sin embargo, de una manera u otra el trabajo realizado por el proceso se pierde, algo que en algunos casos resulta inadmisible, como en sistemas en tiempo real. Aunque parezca una medida drástica, es la empleada en sistemas operativos convencionales. Aplicar el criterio de selección y eliminar procesos cuando el número de procesos es relativamente bajo puede solucionar el interbloqueo, pero si se da un bloqueo de por ejemplo, centenares de procesos, es una situación prácticamente inmanejable.

* ''Apropiación temporal'': Se retira la asignación de un recurso a un proceso (durante el tiempo necesario) para deshacer el interbloqueo (hemos de asegurarnos de que el proceso no se desbloquea al romperse el interbloqueo). Por ejemplo, supongamos que el recurso es una impresora: podríamos retirarle la asignación a un proceso P1 cuando este terminase de imprimir una página, asignarle la impresora a otro proceso P2 y volver a asignársela a P1 cuando P2 haya terminado su ejecución. El problema es que este método solo es posible dependiendo de la naturaleza del proceso. Con frecuencia es imposible recuperarse de esta manera ya que los recursos no pueden ser apropiados.

* ''Puntos de conformidad'',''sincronismo'' o ''checkpoints'': Consiste en tomar una imagen del estado del proceso, ya sea periódicamente o a instancia del propio proceso, de manera que si se produce un interbloqueo se vuelve a un estado de la ejecución anterior. Son muy poco usados ya que tienen un elevado coste en memoria y existe la posibilidad de que un proceso permanezca indefinidamente sin progresar, y no todos los recursos permiten almacenar y recuperar su estado. Además, puede darse el caso de que el estado del proceso sea externo al sistema (Como en el caso de una conexión a Base de Datos)

== Prevención ==

La prevención apunta a una serie de estrategias que eviten el interbloqueo. Concretamente, son cuatro las estrategias de prevención posibles en base a los principios que [http://en.wikipedia.org/wiki/Edward_G._Coffman,_Jr. Coffman] estableció como interbloqueo. Dichas estrategias son:

* ''Supresión de exclusión mutua'': Un proceso no puede tener acceso exclusivo a un recurso. No siempre es posible, y puede que lo único que haga sea cambiar el problema de sitio. Es una solución drástica, inviable. Por ejemplo, permitir que dos procesos usaran a la vez una impresora sería caótico.
* ''Supresión de retención y espera'' (1ª estrategia de Havender): El proceso debe tener asignado todos los recursos necesarios al inicio y no liberarlos hasta que éste finalice, se consigue utilizando un mismo semáforo para todos los recursos necesarios por el proceso. Esto presenta un inconveniente: si un recurso sólo se utiliza al final, estará ocupado durante toda la ejecución, no permitiendo ser usado por otros procesos. El aprovechamiento de recursos puede mejorarse mediante una programación más elaborada, dividiendo la ejecución del proceso en distintas fases y gestionando los recursos para cada una de ellas. Sin embargo, muchos procesos no saben cuántos recursos necesitarán hasta que hayan empezado a ejecutarse. No obstante, esta estrategia presenta unos inconvenientes: la posibilidad de aplazamiento indefinido por parte de aquellos procesos que usan más recursos, que siempre cuando no le falta uno le falta otro, lo que concluye en un mal aprovechamiento de recursos, obligando a los procesos a solicitar los recursos antes de que les haga falta y atentando contra el objetivo eficiente que nos proponemos.
* ''Supresión de no apropiación'' (2ª estrategia de Havender): Si un proceso está en ejecución y no puede obtener un recurso, dicho proceso libera todos los recursos que está usando y espera a que todos los que necesita estén disponibles. Es una estrategia optimista, usada cuando la probabilidad de que se produzca un interbloqueo en el sistema es baja. Problemas: se puede perder trabajo, además de presentar una carga extra la realización de peticiones.
* ''Supresión de espera circular'' (3ª estrategia de Havender): Si todos los recursos comunes a varios procesos se solicitan siempre en el mismo orden no se producen interbloqueos. De esta manera, se ordenan los recursos y se solicitan en ese orden. Por ejemplo: tenemos un proceso P1 y otro P2, de manera que ambos hacen uso de los recursos X e Y. En el siguiente caso, no pedirían los recursos en el mismo orden:

{| {{table}}
| align="center" style="background:#f0f0f0;"|'''P1:'''
| align="center" style="background:#f0f0f0;"|'''P2:'''
|-
| down(X)||down(Y)
|-
| down(Y)||down(X)
|-
| …||…
|-
| up(Y)||up(X)
|-
| up(X)||up(Y)
|}

Si se ejecuta la instrucción down(X) de P1, se conmuta a P2 y se ejecuta down(Y), se producirá un interbloqueo, ya que ambos estarán esperando a que el otro libere el recurso que necesitan.
Sin embargo, si pedimos los recursos siempre en el mismo orden de la siguiente forma:

{| {{table}}
| align="center" style="background:#f0f0f0;"|'''P1:'''
| align="center" style="background:#f0f0f0;"|'''P2:'''
|-
| down(X)||down(X)
|-
| down(Y)||down(Y)
|-
| …||…
|-
| up(Y)||up(Y)
|-
| up(X)||up(X)
|-
|
|}

Se puede comprobar que es imposible que se de un interbloqueo como en el caso anterior, ocurriendo lo mismo con cualquier número de procesos y recursos.

El principal inconveniente radica en que a veces, debido a la variedad y al número de recursos y procesos, es muy engorroso mantener un criterio de orden para todos los procesos de todo tipo.

== Predicción ==

El sistema operativo observa la evolución que siguen los procesos, y predice una posible situación de interbloqueo. Si detecta una alta probabilidad de que suceda, adopta una trayectoria de ejecución nueva para los procesos involucrados de manera que se garantice que no va a suceder un interbloqueo.

Si tuviéramos de antemano información sobre cómo los procesos van a usar los recursos, tal vez podríamos forzar un entrelazado de las asignaciones que nunca llevase a interbloqueo. Es un ejemplo el algoritmo del banquero. El inconveniente de este tipo de técnicas es que son poco realistas, ya que en sistemas reales no tenemos forma de predecir a la perfección el futuro de accesos a recursos.

7.3 [[Algoritmo_para_averiguar_interbloqueo | Algoritmo para averiguar interbloqueo]]

Definición de interbloqueo

2016-12-04T09:51:18Z

Enrloport: /* Ejemplo */

También conocido como '''bloqueo mutuo''' o '''deadlock'''.

Es una espera circular permanente de dos o más procesos. Existen una serie de [[Condiciones para el interbloqueo y estrategias de resolución#condiciones|condiciones]] para que se produzca y una serie de [[Condiciones para el interbloqueo y estrategias de resolución#estrategias|estrategias]] para resolverlos.

* Ejemplo simple:

[[Archivo: Ssoo wiki.png]]

Se aprecian dos procesos (P1 y P2), cada uno con un recurso diferente asociado (R1 y R2). Llega un punto en el que el proceso P1 ha adquirido el recurso R1 y el proceso P2 ha adquirido el recurso R2 y cada proceso necesita el otro recurso. Este es el punto de interbloqueo.

Según [http://es.wikipedia.org/wiki/Edsger_Dijkstra Dijkstra], una configuración de procesos y recursos es '''estado seguro''' si a partir de ella podemos seguir ejecutando código, es decir, no se producen interbloqueos.

= Ejemplo =

El siguiente ejemplo ilustra el problema con semáforos.

Dados dos procesos P1 y P2 con el siguiente código, con semáforos '''x''' e '''y''' con contadores a 1:

<pre> P1 P2
-- --

#1 while(1) { #1 while(1) {
#2 down(x); #2 down(y);
#3 acceso recurso_x(); #3 acceso_recurso_y();
#4 down(y); #4 down(x);
#5 acceso_recurso_y(); #5 acceso_recurso_x();
#6 up(y); #6 up(x);
#7 up(x); #7 up(y);
} }
</pre>

El cronograma, suponiendo Round Robin con quantum de 3 unidades sería:

<pre>
X = El proceso pasa a estado bloqueado.
/ = El proceso pasa a estado preparado.
> = Fin de su ejecución
</pre>
<pre>
| #1| #2| #3| | | | #4| |
P1|---|---|---| | | |---X |
| | | | | | | | |
| | | | #1| #2| #3| | #4|
P2| | | |---|---|---| |---X
| | | | | | | | |
|___|___|___|___|___|___|___|___|
0 1 2 3 4 5 6 7 8
</pre>

En el que se puede ver la situación de interbloqueo.

Si repetimos con quantum 4:

<pre>
| #1| #2| #3| #4| | | #5| #6| #7| #1| | | | | #2| #3| #4| / | |
P1|---|---|---|---/ | |---|---|---|---/ | | | |---|---|---X | | |
| | | | | | | | | | | | | | | | | | | | |
| | | | | #1| #2| | | | | #3| #4| #5| #6| | | | #7| #1| #2|
P2| | | | |---|---X | / | |---|---|---|---/ | | |---|---|---X
| | | | | | | | | | | | | | | | | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
</pre>

La condición de carrera se produce igualmente, pero más tarde.

--[[Usuario:Leoberbue|Leoberbue]] ([[Usuario discusión:Leoberbue|discusión]]) 16:50 25 nov 2014 (CET)

7.2 [[Condiciones_para_el_interbloqueo_y_estrategias_de_resolución | Condiciones para el interbloqueo y estrategias de resolución]]

Ejercicios sincronización y comunicación

2016-12-04T09:49:21Z

Enrloport: /* Ejercicio 9 */

= Ejercicio 1 =

Realice el cronograma temporal que represente la ejecución de dos procesos P1 y P2. El proceso P1 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
down(s1); /* #2 */
f1(); /* #3 */
if (get(s1) == 0) /* #4 */
up(s2); /* #5 */
}
</source>

Y el proceso P2 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
down(s2); /* #2 */
f2(); /* #3 */
up(s1); /* #4 */
}
</source>

Para el semáforo s1 el contador vale 1, mientras que para el semáforo s2 el contador vale 0.

Suponga que:

* El planificador emplea turno rotatorio estricto con quantum de 3 unidades de ejecución.
* Se sabe que el proceso P2 es seleccionado en primer lugar por el planificador para ejecutarse.
* La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las líneas de código toman el mismo tiempo de ejecución.
* La función get(semáforo s) devuelve el valor del contador del semáforo.

El cronograma deberá incluir qué línea de código se ejecuta en cada unidad de ejecución.

[[solución ejercicio 1|Ver solución del ejercicio 1]]

= Ejercicio 2 =

Realice el cronograma temporal que represente la ejecución de dos procesos P1 y P2. El proceso P1 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
down(s1); /* #2 */
f1(); /* #3 */
up(s2); /* #4 */
}
</source>

Y el proceso P2 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
down(s2); /* #2 */
f2(); /* #3 */
up(s1); /* #4 */
}
</source>

Para el semáforo s1 el contador vale 1, mientras que para el semáforo s2 el contador vale 0.

Suponga que:

* El planificador emplea turno rotatorio estricto con quantum de 3 unidades de ejecución.
* Se sabe que el proceso P1 es seleccionado en primer lugar por el planificador para ejecutarse.
* La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las instrucciones toman el mismo tiempo de ejecución.

El cronograma deberá incluir qué instrucción se ejecuta en cada unidad de ejecución.

[[solución ejercicio 2|Ver solución del ejercicio 2]]

= Ejercicio 3 =

En un exámen de sistemas operativos, un estudiante plantea la siguiente solución basada en dos procesos, un proceso P1 productor y un proceso P2 consumidor, en el que el contador de los semáforos s1 y s2 valen inicialmente 0.

<source lang="c">
while(1) {
down(s1);
produce();
up(s2);
}
</source>

Y el proceso P2 ejecuta el siguiente código:

<source lang="c">
while(1) {
down(s2);
consume();
up(s1);
}
</source>

Responda brevemente si la solución que propone es idónea justificando su respuesta.

[[solución ejercicio 3|Ver solución del ejercicio 3]]

= Ejercicio 4 =

Realice el cronograma temporal que represente la ejecución de dos procesos P1 y P2. El proceso P1 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
send(msg, P2); /* #2 */
recv(msg, P2); /* #3 */
}
</source>

Y el proceso P2 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
recv(msg, P1); /* #2 */
send(msg, P1); /* #3 */
}
</source>

Suponga que:

* El planificador emplea turno rotatorio estricto con quantum de 3 unidades de ejecución.
* Se sabe que el proceso P1 es seleccionado en primer lugar por el planificador para ejecutarse.
* La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las instrucciones toman el mismo tiempo de ejecución.
* El comportamiento de la primitiva send() es síncrono y el la primitiva recv() es bloqueante.
* Suponga que msg contiene un mensaje que se emplea como testigo y cuyo contenido no tiene relevancia.

El cronograma deberá incluir qué instrucción se ejecuta en cada unidad de ejecución.

[[solución ejercicio 4|Ver solución del ejercicio 4]]

= Ejercicio 5 =

Realice el cronograma temporal que represente la ejecución de dos procesos P1 y P2. El proceso P1 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
down(s1); /* #2 */
f1(); /* #3 */
up(s2); /* #4 */
}
</source>

Y el proceso P2 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
down(s2); /* #2 */
f2(); /* #3 */
up(s1); /* #4 */
}
</source>

Para el semáforo s1 el contador vale 1, mientras que para el semáforo s2 el contador vale 0.

Suponga que:

* El planificador emplea turno rotatorio estricto, con quantum ilimitado, por tanto, un proceso se mantiene en estado activo hasta que realice una operación bloqueante.
* Se sabe que el proceso P2 es seleccionado en primer lugar por el planificador para ejecutarse.
* La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las instrucciones toman el mismo tiempo de ejecución.

El cronograma deberá incluir qué instrucción se ejecuta en cada unidad de ejecución.

[[solución ejercicio 5|Ver solución del ejercicio 5]]

= Ejercicio 6 =

Dado dos procesos P1 y P2 cuyos códigos son los siguientes:

Código del Proceso 1:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
send(msg); /* #2 */
f(msg); /* #3 */
recv(msg); /* #4 */
}
</source>

Código del Proceso 2:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
recv(msg); /* #2 */
f(msg); /* #3 */
send(msg); /* #4 */
}
</source>

Suponga que:

* El planificador emplea turno rotatorio estricto con quantum de 3 unidades de ejecución.
* Se sabe que el proceso P1 es seleccionado en primer lugar por el planificador para ejecutarse.
* La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las instrucciones toman el mismo tiempo de ejecución.
* El comportamiento de la primitiva send() es asíncrono y el de la primitiva recv() es bloqueante.
* Suponga que msg contiene un mensaje inicialmente bien formado cuyo contenido no tiene relevancia

El cronograma deberá incluir qué instrucción se ejecuta en cada unidad de ejecución.

[[solución ejercicio 6|Ver solución del ejercicio 6]]

= Ejercicio 7 =

En base a dos hilos h1 y h2 de un mismo proceso P cuyos codigos son los siguientes:

En el hilo h1 se ejecuta el siguiente código:

<source lang="c">
for (int i = 0; i<2; i++){ //#1
while(cerrojo_p2); //#2
cerrojo_p1 = 1; //#3
f(); //#4
cerrojo_p1 = 0; //#5

}
</source>

<source lang="c">
for (int i = 0; i<2; i++){ //#1
while(cerrojo_p1); //#2
cerrojo_p2 = 1; //#3
f(); //#4
cerrojo_p2 = 0; //#5

}
</source>
Proponga una solución en la que se reemplacen los cerrojos por semáforos. Realice el cronograma temporal de ejecución de la solución que propone.

Siendo cerrojo_p1 y cerrojo_p2 variables globales inicialmente a cero.

[[Usuario:Migoligon|Migoligon]] 17:57 4 dic 2011 (UTC)Creí que en el ejercicio 3 quedó claro que no debian iniciarse ambas a 0 porque era un error garrafal. Y ahora me encuentro esto y en las soluciones no diferencia s1 de s2, además de que la solución está preparada para que sea s1 = 1 y s2 = 0 no se de donde han sacado los datos para hacer la solución pero no creo que desde aqui.

Supongamos que:
*El planificador emplea turno rotatorio estricto con quantum de 3 unidades de ejecución.
*Se sabe que el hilo h1 es seleccionado en primer lugar por el planificador para ejecutarse.
*La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las instrucciones toman el mismo tiempo de ejecución.
el planificador

[[Usuario:Juacordia|Juacordia]] 16:33 5 dic 2011

Hola [[Usuario:Migoligon|Migoligon]] creo que estas confundiendo cerrojos por semaforos, una cosa es que los semaforos no puedan estar inicializados a cero y otra son los cerrojos. Espero haberte ayudado. PD: Los semaforos puedes ponerlos de otra manera.

[[solución ejercicio 7|Ver solución del ejercicio 7]]

= Ejercicio 8 =

Realice el cronograma temporal que represente la ejecución de dos procesos P1 y P2. El proceso P1 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
down(s1); /* #2 */
f1(); /* #3 */
up(s1); /* #4 */
}
</source>

Y el proceso P2 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
down(s2); /* #2 */
f2(); /* #3 */
up(s2); /* #4 */
}
</source>

Suponiendo que los contadores de los semáforos s1 y s2 valen 1.

Suponga que:

* El planificador emplea turno rotatorio estricto con quantum de 3 unidades de ejecución.
* Se sabe que el proceso P1 es seleccionado en primer lugar por el planificador para ejecutarse.
* La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las instrucciones toman el mismo tiempo de ejecución.

El cronograma deberá incluir qué instrucción se ejecuta en cada unidad de ejecución.

[[solución ejercicio 8|Ver solución del ejercicio 8]]

= Ejercicio 9 =

Realice el cronograma temporal que represente la ejecución de dos procesos P1 y P2. El proceso P1 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
down(s); /* #2 */
f1(); /* #3 */
up(s); /* #4 */
}
</source>

Y el proceso P2 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
down(s); /* #2 */
f2(); /* #3 */
up(s); /* #4 */
}
</source>

Suponiendo que el contador del semáforos s vale 1.

Suponga que:

* El planificador emplea turno rotatorio estricto con quantum de 3 unidades de ejecución.
* Se sabe que el proceso P1 es seleccionado en primer lugar por el planificador para ejecutarse.
* La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las instrucciones toman el mismo tiempo de ejecución.

El cronograma deberá incluir qué instrucción se ejecuta en cada unidad de ejecución.

[[solución ejercicio 9|Ver solución del ejercicio 9]]

7.1[[Definición_de_interbloqueo | Definición de interbloqueo]]

Mensajería

2016-12-04T09:47:39Z

Enrloport: /* Referencias */

Un mensaje es un contenedor que se emplea para intercambiar información entre dos o más procesos. Los mensajes tienen un cierto formato generalmente compuesto por una cabecera, que contiene información sobre la fuente y el destinatario, y un cuerpo, que contiene información específica.

Los mecanismos de mensajería se refiere al conjunto de funcionalidades que permiten al sistema operativo realizar la entrega de un mensaje a uno o varios procesos. Mediante dicho mecanismo también es posible resolver problemas de concurrencia.

Los sistemas operativos generalmente ofrecen dos llamadas al sistema para que un proceso pueda enviar y recibir mensajes:

* '''send(destino, mensaje)''': Envía un mensaje a un destino.
* '''receive(fuente, mensaje)''': Recibe un mensaje de una fuente.

Una operación compuesta derivada de las primitivas básicas es:

* '''sendrec (dest_fuent, mensaje)''': Envía un mensaje a un destino y recoge la respuesta.

Cualquier proceso que necesite comprobar si tiene mensajes para ser procesados por él debe invocar la llamada al sistema '''recv'''.

== Formas de identificación ==

Para identificar la fuente y el destino de nuestro mensaje se pueden emplear dos estrategias.

=== Denominación Directa ===

En este caso se emplea un ID que permite identificar a la fuente y al destinatario de manera unívoca en el sistema, por ejemplo, el PID de un proceso. La denominación directa permite tres configuraciones:

* ''Unicast'', de manera que la comunicación sucede entre una fuente y un destinatario.
* ''Broadcast'', el emisor envía un mensaje a '''todos''' los procesos existentes en el sistema.
* ''Multicast'', el emisor envía un mensaje a un grupo de procesos, siendo un grupo un subconjunto de procesos existentes en el sistema. El sistema operativo debe ofrecer llamadas al sistema que permitan a los procesos crear grupos y suscribirse a ellos. Un proceso puede suscribirse a tantos grupos como le sea necesario.

El principal inconveniente de la denominación directa es que se pierde el mensaje si el destino no se encuentra.

=== Denominación Indirecta ===

Se emplea un elemento intermediario denominado ''buzón''. El sistema operativo ofrece llamadas al sistema que permiten la creación y destrucción de buzones, por ejemplo, '''CreateMailbox''' y '''DestroyMailbox'''. Una vez creado el buzón, se emplea éste para realizar la comunicación entre procesos.

Con los buzones se pueden emplear cuatro formas diferentes de comunicación:
*Buzón limitado : De un proceso a otro.
*Buzón de entrada: De varios a uno.
*Buzón de salida: De uno a varios.
*Buzón múltiple: Varios procesos entre sí con el mismo buzón.

El receptor no conoce la identidad de quien envía el mensaje, a menos que el SO se haya encargado de ello. El problema surge cuando un proceso intruso y éste lee los mensajes de los buzones. Para remediarlo el SO establece permisos de acceso o contraseñas. O para evitar que el proceso infiltrado manipule los mensajes se puede también implementar firmas de certificación. y así garantizar la identidad de los remitentes.

== Formas de transmisión ==

Distinguimos tres formas de transmisión: Transmisión por copia, transmisión por referencia y transmisión por copia en caso de escritura.

=== Transmisión por copia ===

Si se emplea ''denominación directa'', al invocar el receptor la llamada ''recv'', el mensaje se copia del espacio de memoria del emisor al espacio de receptor. Esta forma de implementar la transmisión tiene un coste de orden lineal <math>O(n)</math>.

Si se emplea ''denominación indirecta'', al invocar ''send'' el emisor, el mensaje se copia del espacio de emisor al espacio del buzón, que se encuentra en el espacio de memoria del sistema operativo. Una vez que el receptor invoca ''receive'', se copia el mensaje al espacio de memoria que el receptor ha habilitado para almacenar el mensaje.

[[Archivo:SSOOMensajeria1.jpg]]

=== Transmisión por referencia ===

Es una mejora frente al mecanismo de transmisión por copia. Básicamente, en lugar de copiar el mensaje, lo que supone un coste de <math>O(n)</math>, se le devuelve al receptor una dirección de memoria en la que se encuentra el mensaje, lo que supone únicamente 4 u 8 bytes dependiendo del tamaño de palabra del procesador (si es de 32-bits o 64-bits).

Si se emplea junto a la '''denominación directa''', el sistema operativo le devuelve al receptor un puntero a la dirección en la que se encuentra el mensaje. Si el mensaje está en el espacio del emisor, son necesarios mecanismos explícitos de compartición de memoria entre procesos, ya que dos procesos cualquiera no comparten memoria. Si el mensaje está en el espacio del sistema operativo, éste debe ofrecer a los procesos mecanismos para acceder a su espacio de memoria-

Si se emplea junto a la '''denominación indirecta''', el emisor crea un mensaje en el espacio del sistema operativo y se le ofrece un puntero al receptor.
[[Archivo:SSOOMensajeria2.jpg]]

=== Transmisión por copia en caso de escritura (COW) ===

Este método permite que los procesos emisor y receptor tengan acceso a la zona de memoria del mensaje de forma controlada. La zona puede pertenecer a uno de los procesos, o al SO, y se accede a ella a través de una ventana en el espacio de direcciones que inicialmente sólo permite consultar la información.

Cuando uno de los procesos intenta modificar el contenido del mensaje, se detecta esta escritura gracias al mecanismo de protección de la memoria. Entonces, el SO hace una copia para uno de ellos, actualiza las referencias, y deja que ambos procesos continúen.

Se mantiene un único espacio mientras sea posible. Si en muchas ocasiones se accede al mensaje para leer de él, se consigue un ahorro importante de espacio y tiempo. Pero hará falta incluir algún servicio para notificar al SO que ya no se necesita el espacio que haya asignado a la copia del mensaje, y que lo libere.

== Formas de comunicación ==

* Comportamiento del emisor, '''send()'''
** ''Síncrona'': el proceso emisor que realiza el send() queda bloqueado hasta que el receptor llama a recv() y el proceso bloqueado pasa a estado preparado.
** ''Asíncrona'': suponemos una estructura de datos con capacidad de almacenamiento limitada, dependiente del proceso destinatario o en el buzón del SO. Al ser enviados, los mensajes irán encolándose para que el proceso receptor pueda gestionarlos cuando pueda. De esta manera se aumenta el rendimiento pero se requiere de políticas adicionales de tratamiento de los mensajes si la capacidad de almacenamiento de la estructura de datos se ve sobrepasada(PE, eliminación de mensajes, realocalización de memoria, etc..)

* Comportamiento del receptor, '''recv()'''
** ''Bloqueante'': una llamada a recv() sin mensajes a procesar pasa el proceso llamante a estado bloqueado. Un send() de otro proceso que añada un mensaje a la cola del proceso bloqueado hace que éste pase a estado preparado.
** ''No bloqueante'': una llamada a recv() sin mensajes a procesar devuelve un mensaje de error, pero la ejecución del proceso llamante continúa.

Entendemos por proceso llamante a aquel que hace uso de las llamadas send() y recv().

== Formato de los mensajes ==

=== Fijo ===

Los procesos acuerdan emplear un formato fijo para sus mensajes.

'''Ejemplo''': Simple Network Time Protocol.<ref> Véase http://tools.ietf.org/html/rfc4330, sección 4, Message Format.</ref>

1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|LI | VN |Mode | Stratum | Poll | Precision |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Root Delay |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Root Dispersion |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Reference Identifier |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| |
| Reference Timestamp (64) |
| |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| |
| Originate Timestamp (64) |
| |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| |
| Receive Timestamp (64) |
| |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| |
| Transmit Timestamp (64) |
| |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Key Identifier (optional) (32) |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| |
| |
| Message Digest (optional) (128) |
| |
| |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

=== Variable ===

* Text-based human-readable.

#Comma-Separated Value (CSV). http://en.wikipedia.org/wiki/Comma-separated_values
#Extensible Markup Language (XML). http://en.wikipedia.org/wiki/XML
#JavaScript Object Notation (JSON). http://en.wikipedia.org/wiki/JSON

=== Mixto ===

Los procesos acuerdan emplear mensaje con partes cuyo formato es fijo, como por ejemplo una cabecera inicial, seguido de partes de tamaño variable.

* Type-Length-Value

'''Ejemplo''': Usado en Netlink para la codificación de atributos de un mensaje.<ref>Ver Communicating between the kernel and user-space in Linux using Netlink Sockets (http://1984.lsi.us.es/~pablo/docs/spae.pdf)</ref>
{| border="2" cellpadding="4" cellspacing="0" style="margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;"
|+ align="center" style="background:DarkSlateBlue; color:white"|'''Type-Length-Value'''
! width="15 px" style="background:#efefef;" | 0
! width="15 px" style="background:#efefef;" | 1
! width="15 px" style="background:#efefef;" | 2
! width="15 px" style="background:#efefef;" | 3
! width="15 px" style="background:#efefef;" | 4
! width="15 px" style="background:#efefef;" | 5
! width="15 px" style="background:#efefef;" | 6
! width="15 px" style="background:#efefef;" | 7
! width="15 px" style="background:#efefef;" | 8
! width="15 px" style="background:#efefef;" | 9
! width="15 px" style="background:#efefef;" | 10
! width="15 px" style="background:#efefef;" | 11
! width="15 px" style="background:#efefef;" | 12
! width="15 px" style="background:#efefef;" | 13
! width="15 px" style="background:#efefef;" | 14
! width="15 px" style="background:#efefef;" | 15
! width="15 px" style="background:#efefef;" | 16
! width="15 px" style="background:#efefef;" | 17
! width="15 px" style="background:#efefef;" | 18
! width="15 px" style="background:#efefef;" | 19
! width="15 px" style="background:#efefef;" | 20
! width="15 px" style="background:#efefef;" | 21
! width="15 px" style="background:#efefef;" | 22
! width="15 px" style="background:#efefef;" | 23
! width="15 px" style="background:#efefef;" | 24
! width="15 px" style="background:#efefef;" | 25
! width="15 px" style="background:#efefef;" | 26
! width="15 px" style="background:#efefef;" | 27
! width="15 px" style="background:#efefef;" | 28
! width="15 px" style="background:#efefef;" | 29
! width="15 px" style="background:#efefef;" | 30
! width="15 px" style="background:#efefef;" | 31

|-
| colspan=16, align="center"| Length
| colspan=16, align="center"| Type
|-
| colspan=32, align="center"| Value
|}

== Mensajería a través de la red ==

* Unicidad del destinatario
* Fiabilidad en la transmisión
* Formato de los datos (http://www.cs.umd.edu/class/sum2003/cmsc311/Notes/Data/endian.html): Enviar un entero a través de la red puede ser un problema debido a la forma en el que se representan los datos en la memoria dependiente de la arquitectura. Por ejemplo, un PC con arquitectura Intel x86 emplea formato little-endian, mientras que un SPARC de Sun Microsystems (ahora Oracle) emplea big-endian.

** Little Endian: Bytes menos significativo al principio.

<source lang="c">
int main(void)
{
int a = 10, i;
char *p = &a;

for (i=0; i<sizeof(a); i++) {
printf("posición %d: %.2x\n", i, p[i]);
}
}
</source>

Muestra el siguiente resultado en un PC:

posición 0: 0a (n+3)
posición 1: 00 (n+2)
posición 2: 00 (n+1)
posición 3: 00 (n)

** Big Endian: Bytes menos significativo al final.

posición 0: 00 (n)
posición 1: 00 (n+1)
posición 2: 00 (n+2)
posición 3: 0a (n+3)

En Internet se sigue la convención de expresar datos en Big Endian, habría que hacer la conversión. Habría que usar '''ntohl''' (network to host long).

En little-endian, la implementación de ntohl es la siguiente:

#define __constant_ntohl(x) ___constant_swab32((__be32)(x)

Ver /usr/include/linux/byteorder/little_endian.h

mientras que en big-endian es:

#define __constant_ntohl(x) ((__u32)(__be32)(x))

Si empleamos formato textuales, como CSV, XML o JSON, que codifican la información en bytes, no tenemos este problema.

==Referencias==
<references/>

6.8 [[Ejercicios_sincronización_y_comunicación | Ejercicios sincronización y comunicación]]

Monitores

2016-12-04T09:45:54Z

Enrloport: /* Fuentes */

Idea desarrollada en los años 70 Brinch-Hansen y Hoare (https://web.archive.org/web/20091229162223/http://java.sun.com/developer/Books/performance2/chap4.pdf), que notaron los siguientes problemas con respecto al uso de los semáforos:

* Los semáforos son difíciles de usar. Es frecuente que el programador cometa errores al emplearlos.
* El compilador no asiste al programador en el desarrollo de programas concurrentes mediante semáforos, pues no ofrece ningún tipo de validación en tiempo de compilación.
* No hay nada que obligue a usarlos. Puede suceder que el programador los necesite y lo desconozca
* Son independientes del recurso compartido

Los monitores tienen que estar integrados en el lenguaje de programación.

== Definición ==
Un monitor es una estructura del lenguaje cuyas principales características son:

* Los datos son privados.
* Ofrecen una serie de métodos públicos para acceder a dichos datos.
* En cada momento sólo puede haber un proceso activo en algún método del monitor, es decir, ejecutando código de esos métodos públicos del monitor. Seria equivalente a decir que el recurso que queremos compartir se declara como monitor. Los procesos que usan el monitor son independientes unos de otros y cuando deseen usar el recurso, llamarán a los métodos del monitor que implementen la operación que se desea ejecutar.

Permiten organizar procesos en espera mediante:

* Variables de condición: lista de procesos inicialmente vacía.
* Primitivas: ''wait(c)'', añade el proceso p invocante a c y proceso p bloquea; ''signal(c)'', selecciona a uno de los procesos en c y lo pone en preparado.

<source lang="java">

class recursoCompartido {

private int recursoCompartido;
private Semaforo s = 1;

public int get(void){
int ret; #1
down(s); #2
ret = recursoCompartido; #3
up(s); #4
return ret; #5
}

public void set(int valor){
down(s); #1
recursoCompartido = valor; #2
up(s); #3
}
}
</source>

Como vemos, los monitores se implementan con semáforos, son una abstracción de los mismos.

== Ejemplo del funcionamiento de una clase monitor ==

Dado un cierto recurso compartido protegido por una clase monitor denominada ''RecursoCompartido'' con los siguientes métodos:

* '''get''', permite obtener el valor del recurso compartido, devuelve un entero.
* '''set''', permite establecer el valor del recurso compartido.

Suponga ya creada un objeto RecursoCompartido para dos hilos h1 y h2:

<source lang="java">
RecursoCompartido r = new RecursoCompartido();
</source>

Dichos hilos tienen el siguiente código:

* Lector (h1):

<source lang="java">
int valor;
for(int j=0; j<2; j++) { #1
valor=r.get(); #2
print(valor); #3
}
</source>

* Escritor (h2):

<source lang="java">
int i=0;
for(int j=0; j<2; j++) { #1
r.set(i); #2
i++; #3
}
</source>

Suponiendo turno rotatorio estricto con quantum de 4 unidades de tiempo y que el planificador da paso en primer lugar al hilo h1. El cronograma con la representación de la ejecución sería el siguiente:

< = lanzamiento del proceso
> = finalización del proceso
x = indica que el proceso está asignado al procesador en ese momento.
B = el proceso pasa a estado bloqueado
P = el proceso pasa a estado preparado

Asignación del recurso procesador

| 1 |2.1|2.2|2.3| | |2.4|2.5| 3 | 1 | | | | |2.1|2.2|2.3|2.4| | | | |2.5| 3 | 1 | |
h1 <---|---|---|---P | |---|---|---|---P | | | |---|---|---|---| | | | |---|---|---> |
| | | | | 1 |2.1| | | | |2.2|2.3| 3 | 1 | | | | |2.1|2.2|2.3| 3 | | | | 1 |
h2 | | | | <---|---B P | | |---|---|---|---P | | | |---|---|---|---| | | |--->
----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

Nota: Los números de la parte superior a los guiones, indican el número de instrucción que
se está ejecutando en dicho momento. En el caso de los 2.1, 2.2 y sucesivos se
refieren al número de instrucción qué internamente se ejecutan en el get() y set()
del monitor (Ver la implementación de la clase monitor de RecursoCompartido vista en clase).

[[Usuario:Migoligon|Migoligon]] 16:51 4 dic 2011 (UTC)Porqué h1 no tiene la P de preparado en el 2.4 ni h2 en el último 3, y porqué h2 no se bloquea en el 2º down??

H1 y H2 si pasan a preparado en 2.4 y 3 respectivamente, si no está la P será por olvido. Por otro lado, H2 no bloquea en el segundo down porque el semáforo en ese instante es s=1. El h1 en el instante 2.4 lo pone a 1, y pasa a preparado por consumir todo el quantum. Cuando h2 hace el down, el contador sigue a 1, lo decrementa y sigue ejecutando código.

En la página de [https://1984.lsi.us.es/wiki-ssoo/index.php/Discusi%C3%B3n:Monitores discusión] hay un ejemplo en java.

Creo que una solución mas correcta es la siguiente:
Asignación del recurso procesador

| 1 | 2 |2.1|2.2| | | |2.3|2.4|2.5| 3 | | | | | 1 | 2 |2.1|2.2| | |2.3|2.4|2.5| 3 |
h1 <---|---|---|---P | | |---|---|---|---P | | | |---|---|---|---P | |---|---|---|---P
| | | | | 1 | 2 |2.1| | | | |2.2|2.3| 3 | 1 | | | | | 2 |2.1| | | | |
h2 | | | | <---|---|---B | P | |---|---|---|---P | | | |---|---B | P | |
----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

| | | | | 1 |
h1 | | | | |--->
|2.2|2.3| 3 | 1 | |
h2 |---|---|---|---> |
|---|---|---|---|---|
25 26 27 28 29 30

--[[Usuario:Mangonvil1|Mangonvil1]] 17:20 14 dic 2011 (UTC)Creo que esta solución sería más correcta puesto que la línea 2 del código de cada hilo(en el hilo 1 el get() y en el hilo 2 el set(i)) hay que tratarla como una unidad de ejecución más. (Pendiente de que Pablo le de el visto bueno)

Esta solución es incorrecta (creo que lo comentó también Pablo en clase) ya que las llamadas a las funciones son en realidad un puntero apuntando a una dirección de la memoria en la que se encuentra esa función (apuntará a la primera línea de ejecución de la función). Para verlo con un ejemplo más de "andar por casa", digamos que sería el equivalente a sustituir en el código del hilo1 la linea #2 por todas las líneas de la función en si, #2.1 #2.2 #2.3 #2.4 y #2.5, la llamada a la función no cuenta como una ejecución más.--[[Usuario:Josazcrom|Josazcrom]] 10:39 14 dic 2011 (UTC)

== Fuentes ==
Tema 4
http://hpjpc.googlecode.com/files/HPJPC%20Christopher%20and%20Thiruvathukal.pdf

6.7[[Mensajería | Mensajería]]

Semáforos

2016-12-04T09:44:57Z

Enrloport: /* Granularidad */

= Planificador de procesos: Diagrama de estados simplicado =

Para comprender apropiadamente cómo funcionan los semáforos es importante recordar cómo funciona el [[Estados de los procesos|diagrama de estados de los procesos]]

= Semáforos =

Los semáforos son un mecanismo de sincronización de procesos inventados por [http://es.wikipedia.org/wiki/Edsger_Dijkstra Edsger Dijkstra] en 1965. Los semáforos permiten al programador '''asistir al planificador del sistema operativo en su toma de decisiones''' de manera que permiten sincronizar la ejecución de dos o más procesos. A diferencia de los [[cerrojos]], los semáforos nos ofrecen un mecanismo de espera no ocupada.

Los semáforos son un tipo de datos que están compuestos por dos atributos:

* Un contador, que siempre vale >= 0.
* Una lista de procesos(lista formada por el PCB de cada proceso), inicialmente vacía.

Y disponen de dos operaciones básicas que pasamos a describir en pseudocódigo:

<source lang="c">
down(semáforo s)
{
si s.contador == 0:
añade proceso a s.lista
proceso a estado bloqueado
sino:
s.contador--
}
</source>

Nótese que siempre que queramos forzar una transición de un proceso a estado bloqueado, tenemos que hacer que dicho proceso realice una operación ''down'' sobre un semáforo cuyo contador vale cero.

<source lang="c">
up(semáforo s)
{
si hay procesos en s.lista:
retira proceso de s.lista
proceso a estado preparado
sino:
s.contador++
}
</source>

Nótese que una operación ''up'' sobre un semáforo en el que hay procesos en su lista resulta en que se retire uno de los procesos (el que más tiempo lleva en la lista), realizando éste la transición a estado preparado. Es un error frecuente pensar que una operación ''up'' resulte en que el proceso retirado de la lista pase a estado activo. Recuerde que las transiciones de estado activo a preparado y viceversa son siempre controladas por el planificador del sistema operativo.

Además, se disponen de un constructor y un destructor que permiten la creación y la liberación de un semáforo.

=== Ejemplo de uso de semáforos ===

Suponga el siguiente ejemplo en el que se quieren sincronizar dos hilos de un proceso, de manera que se dé la siguiente secuencia de ejecución: A, B, A, B, ... y así sucesivamente. El siguiente código resolvería el problema:

<source lang="c">
semaforo a = semaforo.create(1);
semaforo b = semaforo.create(0);

/* código del hilo A */
while (1) {
a.down();
printf("hilo A\n");
b.up();
}

/* código del hilo B */
while (1) {
b.down();
printf("hilo B\n");
a.up();
}
</source>

=== Tipos de semáforos ===

Dependiendo de la función que cumple el semáforo, vamos a diferenciar los siguientes tipos:

* Semáforo de exclusión mutua, inicialmente su contador vale 1 y permite que haya un único proceso simultáneamente dentro de la sección crítica.
* Semáforo contador, permiten llevar la cuenta del número de unidades de recurso compartido disponible, que va desde 0 hasta N.
* Semáforo de espera, generalmente se emplea para forzar que un proceso pase a estado bloqueado hasta que se cumpla la condición que le permite ejecutarse. Por lo general, el contador vale 0 inicialmente, no obstante, podría tener un valor distinto de cero.

=== Ventajas e inconvenientes ===

La principal ventaja de los semáforos frente a los [[cerrojos]] es que permiten sincronizar dos o más procesos de manera que no se desperdician recursos de CPU realizando comprobaciones continuadas de la condición que permite progresar al proceso.

Los inconvenientes asociados al uso de semáforos son los siguientes:

* Los programadores tienden a usarlos incorrectamente, de manera que no resuelven de manera adecuada el problema de concurrencia o dan lugar a interbloqueos.
* No hay nada que obligue a los programadores a usarlos.
* Los compiladores no ofrecen ningún mecanismo de comprobación sobre el correcto uso de los semáforos.
* Son independientes del recurso compartido al que se asocian.

Debido a estos inconvenientes, se desarrollaron los [[Monitores|monitores]].

=== Granularidad ===
Número de recursos controlados por cada semáforo. Hay de dos tipos:
* Granularidad fina: Un recurso por semáforo. Hay un mayor grado de paralelismo, lo que puede mejorar la rapidez de ejecución de la protección. Aunque a mayor número de semáforos existe una mayor probabilidad de que se de un interbloqueo entre semáforos, que no sería una mejora de lo que intentamos evitar.
* Granularidad gruesa: Un semáforo para todos los recursos. Caso totalmente inverso al anterior: Ahora al tener un semáforo no se produce interbloqueo entre ellos, aunque los tiempos de ejecución son excesivamente largos.

6.6[[Monitores | Monitores]]

Solución de los ejercicios de concurrencia

2016-12-04T09:43:52Z

Enrloport: /* Ejercicio 3 */

== Ejercicio 1==

| #1| #2| #3| | | | #4| #1| #2| | | | #3| #4| #1| | | | | | | | |
H1 |<--|---|---| | | |---|---|---| | | |---|---|-->| | | | | | | | |
| | | | | | | | | | | | | | | | | | | | | | | |
| | | | #1| #2| #2| | | | #2| #2| #2| | | | #2| #3| #4| #1| #2| #3| #4| #1|
H2 | | | |<--|---|---| | | |---|---|---| | | |---|---|---|---|---|---|---|-->|
| | | | | | | | | | | | | | | | | | | | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

Algunas observaciones:
* Los hilos '''no''' comparten la variable ''i''. Esta variable se trata de una variable local, por tanto, no es una variable que ambos hilos compartan. Únicamente las variables globales son compartidas por dos o más hilos.
* Al ser los cerrojos un control de concurrencia de espera activa, se comprueba continuamente la condición que nos permite acceder a la sección crítica.

--[[Usuario:Pneira|Pneira]] 07:33 10 may 2011 (UTC)

== Ejercicio 2==

| #1| #2| #3| | | | #4| #5| #1| | | | #2| #2| #2| | |
H1 |<--|---|---| | | |---|---|---| | | |---|---|---| | |
| | | | | | | | | | | | | | | | | |
| | | | #1| #2| #2| | | | #2| #3| #4| | | | #5| #1|
H2 | | | |<--|---|---| | | |---|---|---| | | |---|---|
| | | | | | | | | | | | | | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

| | #2| #3| #4| | | | #5| #1| |
H1 | |---|---|---| | | |---|-->| |
| | | | | | | | | | |
| #2| | | | #3| #4| #5| | | #1|
H2 |---| | | |---|---|---| | |--->
| | | | | | | | | | |
|___|___|___|___|___|___|___|___|___|___|
17 18 19 20 21 22 23 24 25 26 27

Explicación:

En este ejercicio la implementación de cerrojos no resuelve el problema de concurrencia (véase el instante 22, en el que ambos hilos están en la sección crítica).

El problema se debe, como se comentó en clase, a que la comprobación del valor del cerrojo y el establecimiento de su valor debe ser una '''operación atómica'''. Sin embargo, en el instante de tiempo 17 se comprueba el valor del cerrojo pero no se establece el nuevo valor. Es decir, habría que emplear una operación que evite que quedemos entre la comprobación del valor del cerrojo y su modificación.

--[[Usuario:Pneira|Pneira]] 17:06 23 nov 2011 (UTC)

== Ejercicio 3==
Al tener un quantum de únicamente dos unidades, el planificador cambia de proceso antes de actualizar el valor del cerrojo, lo que provoca que se produzca una situación de concurrencia.

6.5[[Semáforos | Semáforos]]

Ejercicio de concurrencia de procesos

2016-12-04T09:43:28Z

Enrloport: /* Ejercicio 3 */

= Ejercicio 1 =

Realice el cronograma temporal que represente la ejecución de un proceso P1 que dispone de dos hilos, h1 y h2. Ambos hilos sincronizan su ejecución mediante cerrojos y ejecutan el mismo código:

<source lang="c">
for (int i=0; i<2; i++) { /* instrucción 1 */
lock(); /* instrucción 2 */
funcion(); /* instrucción 3 */
unlock(); /* instrucción 4 */
}
</source>

Suponga que:

* El planificador emplea turno rotatorio estricto con quantum de 3 unidades de ejecución.
* Se sabe que el hilo h1 es seleccionado en primer lugar por el planificador para ejecutarse.
* La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las instrucciones toman el mismo tiempo de ejecución.

El cronograma deberá incluir qué instrucción se ejecuta en cada unidad de ejecución.

(''[[Solución de los ejercicios de concurrencia|Solución]]'')

== Ejercicio 2==
''[Este ejercicio formó parte del Segundo Control de Evaluación Contínua en el curso 2010/11, del 11 de mayo de 2011]''

Dados dos hilos h1 y h2 de un mismo proceso P cuyos códigos son los siguientes:

'''Código del hilo h1'''
<source lang="c">
for(int i=0; i<2; i++){ /* #1 */
while(cerrojo_p2); /* #2 */
cerrojo_p1 = 1; /* #3 */
f(); /* #4 */
cerrojo_p1 = 0; /* #5 */
}
</source>

'''Código del hilo h2'''
<source lang="c">
for(int i=0; i<2; i++){ /* #1 */
while(cerrojo_p1); /* #2 */
cerrojo_p2 = 1; /* #3 */
f(); /* #4 */
cerrojo_p2 = 0; /* #5 */
}
</source>

Suponga que:

* El planificador emplea turno rotatorio estricto con quantum de 3 unidades de ejecución.
* Se sabe que el hilo h1 es seleccionado en primer lugar por el planificador para ejecutarse.
* La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las instrucciones toman el mismo tiempo de ejecución.

Realice:

* El cronograma temporal que represente la ejecución del proceso P que dispone de dos hilos, h1 y h2. El cronograma deberá incluir qué instrucción se ejecuta en cada unidad de ejecución. Considere que el valor de ambos cerrojos inicialmente es de cero.

* ¿Se produce algún problema derivado de la implementación de cerrojos que se usa en este ejercicio? Indique brevemente de qué se trata el problema.

(''[[Solución de los ejercicios de concurrencia#Ejercicio 2|Solución]]'')

== Ejercicio 3==
''[Este ejercicio formó parte del Segundo Control de Evaluación Contínua en el curso 2010/11, del 11 de mayo de 2011]''

Si el planificador empleara turno rotatorio con quantum de 2 unidades de ejecución, ¿qué sucedería?

(''[[Solución de los ejercicios de concurrencia#Ejercicio 3|Solución]]'')

6.5[[Semáforos | Semáforos]]

Cerrojos

2016-12-04T09:43:00Z

Enrloport: /* Cerrojos mediante instrucciones atómicas */

= Ejemplo de implementación =

El siguiente código sería un posible ejemplo del uso de control de concurrencia mediante cerrojos:

<source lang="c">
int cerrojo = 0; /* Inicializamos la variable cerrojo. Esto sería sólo válido para
hilos, ya que los procesos no comparten espacio de memoria. La variable se inicializa FUERA de los hilos.
Del while en adelante, ya es código perteneciente a los hilos en ejecución. */

while(cerrojo == 1); // Protocolo de
cerrojo = 1; // entrada

... // Sección crítica

cerrojo = 0; // Protocolo de salida
</source>

Sin embargo, esto es problemático: Supongamos que tenemos únicamente un proceso con dos hilos (Hx y Hy) y el planificador retira el hilo Hx justo antes de ejecutarse la instrucción ''cerrojo = 1;''. El hilo Hy ejecuta su código, entra en la sección crítica (Esto puede ocurrir ya que cerrojo sigue a 0) y el planificador le retira el uso del procesador dentro de ésta. A continuación, se le vuelve a asignar el procesador a Hx.

De esta forma, tenemos a dos hilos ejecutando código de la sección crítica. Para evitar este problema, debemos implementar los protocolos de entrada y salida de forma que se ejecuten en una sola instrucción, con lo cual o el planificador retira el uso del procesador antes de esta instrucción, o sino lo retira después de haberla ejecutado.

= Cerrojos mediante instrucciones atómicas =

Podemos implementar cerrojos mediante instrucciones especiales de comprobación y puesta a 0 y 1.

<source lang="c">
int cerrojo = 0;

void lock() {
while (__sync_lock_test_and_set(&cerrojo, 1));
}

void unlock() {
__sync_lock_release(&cerrojo);
}
</source>

El método lock comprueba mediante __sync_locktest_and_set(&cerrojo,1) el valor del cerrojo: si es 0, cambia el valor del cerrojo a 1 y devuelve 0, por tanto, se sale del while y entra en sección crítica; si es 1, devuelve 1 y continúa comprobando el valor, por tanto, no entra en situación crítica hasta que cambie el valor del cerrojo.

El método unlock, mediante _sync_lock_release(&cerrojo), cambia el valor del cerrojo a 0.

* http://gcc.gnu.org/onlinedocs/gcc-4.1.2/gcc/Atomic-Builtins.html
* http://stackoverflow.com/questions/1383363/is-my-spin-lock-implementation-correct-and-optimal

6.4[[Ejercicio_de_concurrencia_de_procesos | Ejercicio de concurrencia de procesos]]

6.5[[Semáforos | Semáforos]]

Mecanismos de sincronización

2016-12-04T09:40:09Z

Enrloport: /* Implementación del control de concurrencia pesimista */

= Optimistas =

Este mecanismo debe emplearse si el programador considera que la frecuencia de acceso a un recurso compartido es baja, es decir, que supone que la probabilidad de coincidencia de dos o más procesos al recurso compartido es baja.

El siguiente ejemplo muestra el código ejecutado por dos hilos: hx y hy de un mismo proceso.

<source lang="c">
int tabla[3] = { 100, 101, 102 }; /* tabla compartida por ambos hilos hx y hy. */

/* actividad del hilo */
void *actividad_hilo(void *ptr)
{
int i;

while(1) {
for (i=0; i<3; i++) {
actualiza_tabla(i);
sleep((random() % 10) + 1); /* hilo pasa a estado bloqueado durante 1 a 10 segundos. */
}
}
return NULL;
}

int main(void)
{
pthread_t hilo1, hilo2;

pthread_create(&hilo1, NULL, actividad_hilo, NULL); /* creación hilox. */
pthread_create(&hilo2, NULL, actividad_hilo, NULL); /* creación hiloy. */
pthread_join(hilo1, NULL);
pthread_join(hilo2, NULL);
}

void actualiza_tabla(int i) {
int tmp;
retry:
tmp = tabla[i]; /* almaceno el valor de la variable compartida en una temporal. */
tmp++; /* actualizo la varible temporal. */
if (tabla[i]+1 != tmp) { /* compruebo si la variable compartida ha sido modificada */
goto retry; /* mientras operaba con la variable temporal. */
}
tabla[i]=tmp;
}
</source>

Los inconvenientes de este tipo de mecanismo son dos:

* Se consume más memoria, pues hay que realizar una copia del recurso compartido para efectuar la actualización.
* En situaciones de coincidencia, se tiene que volver a realizar la operación, por tanto, se desperdician recursos de procesamiento.

En base al ejemplo anterior, hay que garantizar que la operación de comprobación y actualización es '''atómica'''. Se dice que una operación es '''atómica''' cuando es indivisible, es decir, que no quedamos en una situación intermedia al ejecutar dicha operación.

Como ventaja, este tipo de mecanismo nos ofrece un mayor grado de paralelismo, por tanto, una mayor tasa de transferencia, siempre que se emplee en una situación donde la frecuencia de concurrencia sea baja.

Por último, si el programador ha empleado una aproximación optimista para una situación en la que la frecuencia de coincidencia es alta, podría darse el caso de que un hilo no progrese en su ejecución de manera indefinida, al tener que volver a reintentar la actualización una y otra vez hasta conseguirlo sin que haya concurrencia.

Un mecanismo de sincronización optimista funciona de la siguiente manera:

Paso 1. Realiza una copia del estado en el que está el recurso compartido.
Paso 2. Opera con esa copia.
Paso 3. Compruebo si mi copia alterada coincide con el original aplicándole también el tratamiento.

= Pesimista =
Este mecanismo debe emplearse si se considera que la frecuencia de acceso al recurso compartido es alta.

En este mecanismo disponemos de tres partes:

* El protocolo de entrada, en el que se emplea un mecanismo que no permite continuar con la ejecución si otro u otros procesos están accediendo al recurso compartido.
* La sección crítica, en el que se realizan las operaciones pertinentes con el recurso compartido.
* El protocolo de salida, en el que se vuelve a permitir el acceso al recurso compartido.

El siguiente ejemplo muestra como se implementa el control de concurrencia pesimista para 2 hilos, hx y hy:

<source lang="c">
int compartida = 1;
protocolo_de_entrada(); /* no permito acceso a variable compartida. */
compartida++; /* sección crítica: actualización de la variable compartida. */
protocolo_de_salida(); /* vuelvo a permitir acceso a la variable compartida. */
</source>

Los protocolos de entrada y salida son, generalmente, operaciones costosas en términos de recursos de procesamiento, pues requieren el uso de instrucciones atómicas cuyo tiempo de ejecución es alto.

Por último, se podría emplear un control de concurrencia pesimista para resolver un problema que se resuelve con un control de concurrencia optimista, pero no al revés.

== Implementación del control de concurrencia pesimista ==

El control de concurrencia pesimista se puede implementar de dos formas mediante:

* Espera ocupada o activa, mediante '''cerrojos'''. En este mecanismo se comprueba continuamente la condición que permite franquear en el protocolo de entrada, por tanto, el proceso permanece en estado activo comprobando continuadamente la condición que le permite progresar en su ejecución, tiempo que está siendo desaprovechado por el procesador.
* Espera no ocupada o bloqueante, mediante '''semáforos''', '''monitores''' o '''mensajería'''. Estos mecanismos hacen que el proceso pase a estado bloqueado cuando no se puede franquear el protocolo de entrada, por tanto, al quedar un proceso que no puede progresar en estado bloqueado, el planificador de procesos tiene que seleccionar a otro proceso.

Nota aclarativa: Definición de ''espera ocupada o activa''

Esperar a que algo ocurra realizando continuas comprobaciones.
Ejemplo:
…
variable= 0;
while(variable==0);
…

6.3[[Cerrojos | Cerrojos]]

Concurrencia de procesos

2016-12-04T09:39:16Z

Enrloport: /* ¿Cómo provocar errores de concurrencia en Java? */

La concurrencia de procesos se refiere a las situaciones en las que dos o más procesos puedan coincidir en el acceso a un recurso compartido o, dicho de otra forma, que requieran coordinarse en su ejecución. Para evitar dicha coincidencia, el sistema operativo ofrece mecanismos de arbitraje que permiten coordinar la ejecución de los procesos.

= El problema del productor y consumidor =

Un ejemplo de un problema de concurrencia sería el siguiente: Dados dos procesos A (productor) y B (consumidor), suponiendo que ambos se ejecutan indefinidamente en el tiempo, el proceso A debe recibir tiempo de ejecución antes que B, tras esto, el proceso B debe recibir su oportunidad de ejecución, dando paso de nuevo al proceso A y así sucesivamente, siguiendo un esquema de alternancia estricta.

proceso A |-- -- --
|
proceso B | -- -- --
|_____________

Recuerde que el planificador de procesos, al desconocer la naturaleza de los procesos y sus objetivos, no dispone de información suficiente para garantizar la secuencia de ejecución descrita en el ejemplo anterior. Por tanto, suponiendo que ambos procesos se encuentran en estado preparado, podría seleccionar al proceso B para pasar a estado activo antes de seleccionar al proceso A, situación que no es deseada.

Recuerde que el planificador de procesos, como hemos visto en capítulos anteriores, emplea [[Criterios de planificación|criterios de planificación]] que no tienen en consideración el objetivo de los procesos. Podemos decir que el planificador de procesos '''desconoce''' cuál es el propósito de los procesos, únicamente puede observar su comportamiento, es decir, si presentan un comportamiento más o menos interactivo.

Por tanto, el programador, a la hora de modelar los procesos, debe emplear mecanismos de arbitraje que ofrece el sistema operativo y que permiten resolver el problema de concurrencia que se plantee.

= Mecanismos de arbitraje =

Los mecanismos de arbitraje que ofrece el sistema operativo son básicamente dos:

* Mecanismos de '''sincronización''': el sistema operativo ofrece mecanismos que permiten a los procesos coordinar su ejecución para conseguir el objetivo sin que sucedan situaciones no deseadas, como por ejemplo que dos o más procesos coincidan simultáneamente en el acceso a un cierto recurso que no se puede compartir.

* Mecanismos de '''mensajería''': el sistema operativo ofrece mecanismos de comunicación entre procesos mediante mensajes. El intercambio de mensajes entre procesos permite coordinarlos.

= Programación concurrente =

El término programación concurrente se emplea con frecuencia para referirse a un conjunto de programas que funcionan en cooperación.

Hay tres formas de interacción entre procesos cooperativos:

*Concurrencia: Hay un recurso común, si varios procesos modificaran la misma información a la vez , cada uno podría destruir parte del trabajo de los demás. Si lo hacen uno tras otro, en serie, se obtendrá el resultado correcto.

*Sincronización: El Sistema Operativo se encarga de enviarle señales a los procesos para coordinar su evolución y conseguir que progrese armónicamente.

*Comunicación: El S.O. transmite mensajes entre los procesos, que se usan para intercambiar, enviar o recibir información.

Se le llama programación concurrente ya que la concurrencia fue la primera forma de iterar recursos entre procesos cooperativos.

= Sección crítica =

Una ''sección crítica'' se trata de una sección del código que puede ser ejecutada por un único proceso o hilo simultáneamente. Un ejemplo de ''sección crítica'' es la sección de código en la que se accede a un recurso compartido. Para evitar el acceso simultaneo a la sección crítica se emplean mecanismos que garantizan la ''exclusión mutua''.

La exclusión mutua se debe realizar de forma coordinada y eficiente, para ello se requiere:

*No más de un proceso por sección crítica y recurso compartido.

*El mismo proceso no puede usar el mismo recurso compartido indefinidamente.

*Todo proceso debe entrar antes o después a usar el recurso.

*Si el recurso está sin uso, cualquiera que lo requiera dispondrá de él inmediatamente.

*Si hay varios esperando usar el recurso y éste se libera, uno de los que estaba esperando lo usará durante un tiempo determinado.

Para llevar ésto a cabo se necesita un protocolo que indique cuando el recurso está libre y cuando está siendo ocupado.

= Tipos de mecanismos de sincronización =

Los mecanismos de sincronización los podemos catalogar en dos categorías:

*[[Mecanismos de sincronización#Optimista|Optimistas]]: Este mecanismo considera que la frecuencia de acceso a un cierto recurso compartido es ''baja''. Este tipo tiene mas consumo de memoria, ya que tiene que copiar el recurso compartido y en caso de interferencia en el hilo tiene que volver a ejecutarlo y consume mas recursos.

*[[Mecanismos de sincronización#Pesimista|Pesimistas]]: Este mecanismo permite coordinar la ejecución de dos o más procesos que acceden al recurso compartido con una frecuencia ''alta''.

Dependerá del criterio del programador el tipo de mecanismo que utilice ya que puede que no elija el tipo correcto. Por ejemplo, puede que la frecuencia de acceso a un cierto recurso sea alta y el programador le asigna un mecanismo optimista, esto provocaría no obtener el resultado esperado.

== ¿Cómo provocar errores de concurrencia en Java? ==
Pequeño experimento, por si queremos observar como se producen errores de concurrencia en operaciones tan simples como la actualización de una lista.

<source lang="java">
public static void main(String[] args) {

List<Integer> list = new ArrayList<Integer>();

/*
* EXPLICACIÓN:
*
* Tenemos creada una lista global, "list" , que será accedida al mismo
* tiempo por varios hilos. En este código se observa como a veces se
* producen errores de concurrencia al realizar modificaciones sobre la
* lista al mismo tiempo. Este es el motivo por el que debemos usar
* mecanismos como los semáforos u otras técnicas para prevenir este
* tipo de errores.
*
* Los errores de concurrencia en java se muestran como:
* ConcurrentModificationError
*
* También es curioso notar que los errores se dan sobretodo al principio, en
* los 30 primeros segundos, luego hay hilos que no se vuelven a
* ejecutar mientras que un par de ellos de forma aleatoria, se ejecutan
* cíclicamente, uno tras el otro.
*
*/
// -----------------------------------------------------------------------------------------------------------------------

// Los hilos con esta tarea añaden un número aleatorio de 0 a 100 en la
// lista cada seg.
Runnable tarea = () -> {
while (true) {
String nombreHilo = Thread.currentThread().getName();
System.out.println("Hola soy el hilo " + nombreHilo);
list.add(new Random().nextInt(100));
System.out.println(list);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {

e.printStackTrace();
}
}
};

// Los hilos con esta tarea añaden también otro número aleatorio de 0 a
// 100 en la lista cada seg.

Runnable tarea2 = () -> {
while (true) {
String nombreHilo = Thread.currentThread().getName();
System.out.println("Hola soy el hilo " + nombreHilo);
list.add(new Random().nextInt(100));
System.out.println(list);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {

e.printStackTrace();
}
}
};

// Los hilos con esta tarea eliminan un número de una posición aleatoria
// cada seg.
Runnable tarea3 = () -> {
while (true) {
String nombreHilo = Thread.currentThread().getName();
System.out.println("Hola soy el hilo " + nombreHilo);
Random r = new Random(list.size());
if (list.contains(r))
list.remove(r);
System.out.println(list);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {

e.printStackTrace();
}
}
};

//Creación de Hilos.
Thread hilo = new Thread(tarea);
Thread hilo2 = new Thread(tarea2);
Thread hilo3 = new Thread(tarea3);
Thread hilo4 = new Thread(tarea3);
Thread hilo5 = new Thread(tarea);
Thread hilo6 = new Thread(tarea3);

//Ejecución.
hilo.start();
hilo2.start();
hilo3.start();
hilo4.start();
hilo5.start();
hilo6.start();

}

</source>

6.2[[Mecanismos_de_sincronización | Control optimista y pesimista de la concurrencia]]

Sol-ejer-planif-procesos-3

2016-12-04T09:37:43Z

Enrloport: /* Ejercicio 4 */

== Traza de los procesos ==

=== Proceso A ===

1, 2, 3, 4, 3, 4, 3, 5
| | | | |
i=0 Bloquea i=1 Bloquea i=2

=== Proceso B ===

1, 2, 3, 2, 3, 2, 4
| | | |
i=0 i=1 i=2 Bloquea

== Apartado 1 ==

B = El proceso realiza una llamada bloqueante.
+ = El proceso se ejecuta en el procesador 1.
- = El proceso se ejecuta en el procesador 2.
< = Instante de llegada del proceso.
> = Instante de finalización del proceso.
* = El proceso es abortado.

| | | | | | | | 1 | 2 | 3 | 4 | | | | 3 | 4 | | |
Pa < | | | | | | |---|---|---|---B | | P---|---*
| | | | | | | | | |i=0| | | | |i=1| | | |
| | | | | | | | | | | | | | | | | | |
| 1 | 2 | 3 | 2 | 3 | 2 | 4 | | | | | | | | | | | |
Pb <---|---|---|---|---|---|---B | | P FIN | | | | | | |
| | |i=0| |i=1| |i=2| | | | | | | | | | | |
| | | | | | | | | | | | | | | | | | |
| | | | | | | | | | | | | | | | | | |
Planificador 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

Puesto que <math>P_b</math> tiene más prioridad de <math>P_a</math> y ambos se lanzan a la vez, el planificador da paso al proceso <math>P_b</math> en primer lugar. --[[Usuario:Pneira|Pneira]] 12:19 11 nov 2011 (UTC)

== Apartado 2 ==

B = El proceso pasa a estado bloqueado.
P = El proceso pasa a estado preparado.
+ = El proceso se ejecuta en el procesador 1.
- = El proceso se ejecuta en el procesador 2.
< = Instante de llegada del proceso.
> = Instante de finalización del proceso.

| 1 | 2 | 3 | 4 | | | | 3 | 4 | | | | 3 | 5 | | | | |
Pa <+++|+++|+++|+++B | | P+++|+++B | | P+++|+++> | | | |
| | | | | | | | | | | | | | | | | | |
| 1 | 2 | 3 | 2 | 3 | 2 | 4 | | | | | | | | | | |
Pb <---|---|---|---|---|---|---B | | > | | | | | | | |
| | | | | | | | | | | | | | | | | | |
planif. | | | | | | | | | | | | | | | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 t

Recuerda: Que la asignación sea dinámica significa que los procesos '''podrían''' pasar de un procesador a otro si al pasar a estado preparado se encuentran con que el procesador que estaban empleando está ocupado y hay otro procesador libre. --[[Usuario:Pneira|Pneira]] 12:19 11 nov 2011 (UTC)

Revisado. --[[Usuario:Pneira|Pneira]] 18:08 23 nov 2011 (UTC)

= Ejercicio 4 =
+++ Cola 1
--- Cola 2

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

Indice de penalización del ejercicio

-------------
| Ipa= 14/4 |
| Ipb= 14/5 |
| Ipc= 19/6 |
-------------
--[[Usuario:Carcasdel1 && VicMolVaz|JCR]] 21:47 02 Dic 2016

6.1 [[Concurrencia_de_procesos | Concurrencia de procesos]]

Ejercicios otros aspectos de la planificación

2016-12-04T09:37:21Z

Enrloport: /* Ejercicio 4 */

== Ejercicio 1 ==

Dada la siguiente configuración de procesos:
{| 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
| 5
|-
| PB
| 1
| 3
|-
| PC
| 2
| 1
|-
| PD
| 3
| 6
|-
| PE
| 4
| 2
|}

Suponiendo un sistema operativo multiprocesador sobre dos procesadores, realice la traza de la ejecución de dichos procesos para los siguientes criterios de planificación:

* FIFO (no apropiativo)
* SJF (apropiativo y no apropiativo)

[[sol-ejer1-otros-aspectos|Ver solución ejercicio 1]]

== Ejercicio 2 ==
''[Este ejercicio fue parte del primer Control de Evaluación Contínua del Curso 2010/11, del 23 de marzo de 2011]''

Dada la siguiente configuracion de procesos:

{| 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
|}

Teniendo en cuenta el siguiente comportamiento:

* El proceso A cada 1 unidad de tiempo de ejecución bloquea .
* El proceso B cada 3 unidades de tiempo de ejecución bloquea.

Suponga que el tiempo de bloqueo de todos los procesos es de 2 unidades de tiempo debido al tiempo de acesso al dispositivo de E/S.

Realice la traza de ejecución de dichos procesos y los índices de penalización para los siguientes criterios de planificación:

#El siguiente, el más corto apropiativo en un sistema multiprocesador con dos procesadores, solo se ejecutaran procesos en el procesador 2 si el procesador 1 está ocupado. No olvide los tiempos de bloqueo de los procesos A y B. Considere asignación dinámica. (''[[sol-ejer2-1-otros-aspectos|Ver solución]]'')
#Por prioridades apropiativo en tiempo real, suponiendo que C < B < A. No olvide los tiempos de bloqueo de los procesos A y B. (''[[sol-ejer2-2-otros-aspectos|Ver solución]]'')

{| 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;" | Plazo
|-
| PA
| 6
|-
| PB
| 15
|-
| PC
| 15
|}

== Ejercicio 3 ==
''[Este ejercicio formó parte del Primer Parcial de Evaluación Contínua del curso 2011/12 del 8 de Noviembre de 2011]''

Dado el código de los siguientes procesos:

'''Código proceso A:'''
<source lang="c">
int fd; #1
fd = open("fichero.txt", O_WRONLY, 0600); #2
for(int i=0;i<2;i++) { #3
write(fd, "%d", sizeof(int)); #4
}
close(fd); #5
</source>

'''Código proceso B:'''
<source lang="c">
int fd, contador = 0; #1
for(int i=0;i<2;i++) { #2
contador+=2; #3
}
printf("el contador vale: %d\n", contador); #4
</source>

De manera teórica, suponga que la ejecución de cada línea de código toma una unidad de tiempo. Considere que las llamadas '''write''' y '''printf''' son bloqueantes puesto que suponen accesos a dispositivos de E/S, siendo los tiempos de bloqueo de 3 unidades de tiempo.

Realice la traza temporal de ejecución de dichos procesos y los índices de penalización para los siguientes criterios de planificación:

#Por prioridades apropiativo en tiempo real, suponiendo que B>A. No olvide los tiempos de bloqueo de los procesos A y B. Considere que los plazos de ejecucion de proceso A es 16 y de proceso B es 18

#Suponiendo un sistema multiprocesador con dos procesadores. No olvide los tiempos de bloqueo de los procesos A y B. Considere asignación dinámica. Suponga que ambos procesos se lanzan a la vez, pero el planificador da paso en primer lugar al proceso A.

[[sol-ejer-planif-procesos-3|Ver solución del ejercicio 3]]

== Ejercicio 4 ==
''[Este ejercicio fue parte del Primer Control de Evaluación Contínua en el curso 2012/13, del 9 de Noviembre de 2012]''

Dada la siguiente configuracion de procesos:

{| 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
| 4
|-
| PB
| 1
| 5
|-
| PC
| 2
| 6
|}

Teniendo en cuenta el siguiente comportamiento:

El proceso A cada 1 unidad de tiempo de ejecución bloquea

El proceso B cada 3 unidad de tiempo de ejecución bloquea

Suponga que el tiempo de bloqueo de todos los procesos es de 3 unidades de tiempo debido al tiempo de acceso al dispositivo E/S

Realice la traza de ejecución de dichos procesos y los indices de penalización suponiendo que se trata de un planificador basado en multinivel con realimentación:

Existen dos colas, cada proceso de la primera cola recibe un quantum de 1 unidad de tiempo, los de la segunda reciben un quantum 2 unidades de tiempo cada uno de ellos.

- Todos los procesos van inicialmente a la segunda cola.

- Un proceso promociona a la primera cola si emplea todo su quantum de una sola vez.

- Un proceso nunca desciende de la primera cola a la segunda.

- Se da oportunidad de ejecución a los procesos de la primera cola siempre que no haya procesos listos en la segunda cola.

[[sol-ejer-planif-procesos-3|Ver solución del ejercicio 4]]

--[[Usuario:Jescrerui|JCR]] 20:38 19 nov 2012 (UTC)

6.1 [[Concurrencia_de_procesos | Concurrencia de procesos]]

Planificación en sistemas multiprocesadores

2016-12-04T09:35:57Z

Enrloport: /* 5.2 Planificación en sistemas multiprocesadores */

=5.6 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.

[[Ejercicios_otros_aspectos_de_la_planificación | Ejercicios]]

6.1 [[Concurrencia_de_procesos | Concurrencia de procesos]]

Planificación de procesos de tiempo real

2016-12-04T09:31:23Z

Enrloport: /* Métodos de planificación */

== ¿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__|_*__|_5__|_*__|_2__|_1__|
_T/t_|_1__|_*__|_5/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.

5.6 [[Planificación_en_sistemas_multiprocesadores | Planificación en sistemas multiprocesadores]]

Planificadores de sistemas operativos existentes

2016-12-04T09:29:24Z

Enrloport: /* Planificador de Windows */

= Planificador de Linux 2.6 =

Este planificador posee 140 prioridades (de 0 a 139), de 0 a 99 son para tiempo real y para el resto de procesos que no son de tiempo real de 100 a 139 basadas en el Nice(de -20 a 19).

Posee un mapa de bits (140 bits), 1 bit para cada prioridad en la que implementan distintas estructuras SCHED_FIFO y SCHED_RR ambas para tiempo real y el resto SCHED_OTHER. Esta ultima estructura posee el número de procesos preparados y dos colas, una para los procesos pendientes y otra para los que ya han consumido su ''quantum''. Cuando un proceso solo consume una parte de su ''quantum'' es insertado al final de la cola de pendientes con lo que le queda de su ventana de tiempo(es decir, si ha consumido el 25% la siguiente vez que sea asignado al procesador solo tendra el 75% del ''quantum''), y si consume totalmente su tiempo de asignación al procesador este pasa a la cola de consumido hasta que este totalmente vacía la cola de pendientes. (Esto se hace para compensar los procesos más interactivos)

Esquema de estructura de SCHED_OTHER:

struct{
int num_procesos_preparados
cola pendientes
cola consumido_quantum
}

= Planificador Mac Os X (Darwin) =

La planificación en el kernel de Mac OS X esta basada en cuatro listas de ejecución, cada una de ellas con diferente prioridad. Un hilo puede migrar de un nivel de prioridad a otro en función de sus requerimientos, dependiendo de la política en concreto que se utilice en el sistema. En general, es posible manejar estas prioridades mediante los procedimientos definidos en el estándar de llamadas POSIX. Con lo que podemos decir, que se trata de un '''criterio de planificación en colas multinivel''' mezclado con '''prioridades'''. Algo parecido al planificador SCHED_OTHER de Linux.

Las cuatro listas de ejecución que maneja el planificador de Mac OS X, son:

[[Archivo:DarwinSched.svg]]

= Planificador de Windows =

El planificador utiliza un sistema de multi-cola ordenadas por prioridades. Son 32 niveles de prioridades (de 0 a 31) que se dividen de la siguiente forma:

- Niveles 16 a 31: Tiempo Real
- Niveles 1 a 15: Variable
- Nivel 0: Reservado para el sistema

El planificador utiliza Round Robin para recorrer las distintas colas. Tiene un quantum fijo que por defecto valdrá q=2 o q=12, dependiendo de si es un SO de servidor o de usuario. El quantum se puede cambiar entre estos dos valores a través del sistema.

Windows utiliza este sistema de planificación desde Windows NT.
Si quieres saber más del sistema de planificación de Windows puedes leer el libro Windows Internals[http://download.sysinternals.com/Files/WindowsInternals-Ch05.pdf](PDF), donde se explica el funcionamiento y las caracteristicas de todo el SO.

5.5 [[Planificación_de_procesos_de_tiempo_real | Planificación de procesos de tiempo_real]]

Criterios de planificación

2016-12-04T09:27:34Z

Enrloport: /* Colas multinivel con realimentación (feedback) */

=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__|_14_|_3__| z = índice de penalización
_z__|_1__|_8/5|_1__|14/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.

Hay que tener en cuenta que:
* Cuando un proceso consume su quantum pasa al final de la cola de preparados.
* Un proceso en estado bloqueado se inserta en la cola de preparados una vez que pasa el tiempo de bloqueo.

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|

5.4 [[Planificadores_de_sistemas_operativos_existentes | Planificadores de sistemas operativos existentes]]

Índices de evaluación

2016-12-04T09:25:27Z

Enrloport: /* ¿Cómo se evalúa un criterio de planificación? */

= ¿Cómo se evalúa un criterio de planificación? =

En base a los siguientes parámetros:

* '''Throughput''' (tasa de transferencia, en castellano), indica la cantidad de procesos en estado activo por unidad de tiempo. Un throughput alto es un indicador de un buen planificador (se mide en nºprocesos/segundo).
* '''Latencia''', indica el tiempo que tarda un planificador de procesos en seleccionar qué proceso pasa a estado activo. Si el planificador toma mucho tiempo en decidir qué proceso pasa a estado activo, se dice que la latencia será alta (se mide en segundos).

Un buen planificador ofrecerá un throughput alto y una latencia baja.

Además, existen otros índices que nos permiten evaluar el planificador:

* '''Tiempo de ejecución''' (tejecución): Unidades de tiempo que requiere el proceso para finalizar su ejecución.
* '''Tiempo de terminación''' (Tterminación): Diferencia entre el instante de lanzamiento y el instante de terminación.
* '''Tiempo perdido''': T-t . Es el tiempo durante el cual un proceso no está asignado al procesador.
* '''Tiempo de inactividad''': Tiempo durante el cual el procesador está ocioso (''idle'', en inglés), es decir, que no tienen ningún proceso asignado.
* '''Tiempo del sistema''': Tiempo empleado por el [[planificador de procesos|planificador]] para la conmutación de procesos.
* '''Tiempo de espera''': Tiempo desde el instante de lanzamiento hasta que el proceso pasa a estado preparado (se suele despreciar).
* '''Índice de penalización''': <math>\frac{T}{t} = \frac{H_f-H_0}{t} = x</math>. Indica que un proceso ha tardado x-1 veces más en ejecutarse que si hubiera tenido el procesador en exclusividad y sin que se hubiese producido ningún bloqueo. Nótese que el índice de penalización crece rápidamente para procesos cuyo tiempo de ejecución es pequeño, mientras que para procesos con tiempo de ejecución mayores, lo hace de manera más suave.

Suponga el siguiente ejemplo, en el que hay dos procesos <math>P_x</math> y <math>P_y</math>, para ilustrar los índices definidos:

< indica que el proceso está preparado
> indica que el proceso ha finalizado su ejecución
$ indica que al proceso se le ha retirado el procesador
X indica la ejecución del planificador para la conmutación

| | | | | | |
Px <---|---$ |---> | |
Py | | <---> | | |
planificador | | X X | | |
|___|___|___|___|___|___|___
0 1 2 3 4 5 6

tiempo ->

Para el proceso Px:

* t = 3 : Indica que el proceso Px requiere 3 unidades de tiempo para ejecutarse.
* T = 4 : unidades de tiempo desde que se lanza hasta que se finaliza el proceso Px
* T-t = 1 : unidades de tiempo durante la cual el proceso Px no está asignado al procesador, por tanto, no progresa en su actividad.
* x = 4/3 = 1.34 : el proceso Px ha tardado un 34% de tiempo más en ejecutarse que si lo hubiera tenido en exclusividad (al tener que haber que compartido el procesador con Py).

En el ejemplo anterior, los tiempos de espera y del sistema se suponen despreciables (en la práctica no lo son, aunque son muy pequeños con respecto a los ilustrados).

5.3 [[Criterios_de_planificación | Criterios de planificación]]

Planificación de procesos

2016-12-04T09:22:37Z

Enrloport: /* Aspectos para diseñar un buen criterio de planificación */

= 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.

5.2 [[Índices_de_evaluación | Índices de Evaluación]]

Componentes básicos de un sistema operativo

2016-10-23T10:11:04Z

Enrloport:

=2.5. 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:

* Lanzador de aplicaciones: permite el lanzamiento de programas. Suelen ser intérpretes de órdenes textuales o basados en gestores de ventanas.
* Llamadas al sistema: conjunto de servicios que los procesos pueden solicitar al sistema operativo.

2.6.[[Conceptos básicos| Conceptos básicos]]

Componentes básicos de un sistema operativo

2016-10-23T10:09:43Z

Enrloport:

=2.5. 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:

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

2.6.[[Conceptos básicos| Conceptos básicos]]

Modos de operación de la CPU

2016-10-23T09:45:33Z

Enrloport:

= 2.2. Modos de operación de la CPU =

Los fabricantes de procesadores actuales ofrecen procesadores que generalmente disponen de, al menos, dos modos de funcionamiento.

El procesador viene con un juego de instrucciones propio de cada fabricante, algunos ejemplos son: x86, x86_64, sparc, powerpc, ARM, entre muchas otras.

El estado del procesador se guarda en un conjunto de registros de 8, 16, 32 o 64 bits. Además de ellos, el procesador posee dos registros especiales, el de siguiente instrucción (IP, PC,…) y el de estado (CCR):

== No privilegiado ==
También llamado modo usuario (es preferible no usar este término para no llegar a confusión).
* Modo en el que se ejecutan los procesos y bibliotecas del sistema operativo. En el caso concreto de los sistemas operativos [[Modelos de Diseño de Sistemas Operativos|micronúcleos]], los servidores también se ejecutan en modo no privilegiado, tales como el servidor de ficheros, el administrador de memoria y los gestores de dispositivo.

* Ofrece únicamente un subconjunto de las instrucciones disponibles.

* Si en éste modo se intenta ejecutar una instrucción privilegiada, el sistema operativo o bien la ignora, o bien lanza una excepción.

== Privilegiado ==
También llamado modo supervisor (no confundir con usuario root).
* Modo en el que se ejecuta el núcleo del sistema operativo.
* Ofrece acceso total a las instrucciones de la CPU.
Un fallo de programación en modo privilegiado puede plantar el SO, en modo no privilegiado nunca pasaría eso.
Precisamente esa es la utilidad de tener varios modos de ejecución, la construcción de un sistema robusto.
En la práctica, lo usual es que los procesadores tengan modos intermedios entre usuario y supervisor.
La transición de modo supervisor a usuario es arbitraria, mientras que de usuario a supervisor se realiza mediante una interrupción.
La CPU siempre arranca en modo supervisor, lo cual se intuye, pues en el inicio del dispositivo, se tendrá que ejecutar código del sistema operativo.

2.3. [[Interrupciones y excepciones|Interrupciones y excepciones]]

Organización básica de un ordenador

2016-10-23T09:43:01Z

Enrloport:

Un ordenador está compuesto de los siguientes componentes básicos:

* Unidad de procesamiento (CPU). Dispone de juego de instrucciones básicas de bajo nivel (lenguaje ensamblador) definidas por el diseñador/fabricante. Por tanto, el juego de instrucciones y los parámetros que estas toman son diferentes según el tipo de procesador que se esté empleando. Algunos ejemplos de procesadores, son las familias Intel x86 y x86_64, ARM, SPARC y PowerPC, entre muchas otras.
* Memoria principal. Almacena el estado de la ejecución de los procesos, es decir, variables y estructuras de datos empleadas. Es una memoria volátil, por tanto, al dejar de suministrarles energía, la información se desvanece.
* Dispositivos de entrada y salida. Son dispositivos que permiten recibir y enviar datos que pueden ser empleados por los programas en ejecución. Por ejemplo, teclado, ratón, disco duro magnético, tarjeta de red, tarjeta de vídeo, entre muchos otros.

En la arquitectura de Von Neumann, estos tres componentes se comunican a través de un único bus.

2.2. [[Modos de operación de la CPU|Modos de operación de la CPU]]

Virtualización

2016-10-16T18:48:37Z

Enrloport:

== Técnicas de virtualización ==

Las técnicas de virtualización nos permiten ejecutar dos o más sistemas operativos simultáneamente sobre una misma plataforma hardware. Sin ellas esto no es posible. Estas técnicas apuntan principalmente a ahorrar costes en material.

En general, la arquitectura que nos encontramos en un sistema operativo es la siguiente:

------------------------
| P1 | P2 | .... | Px |
------------------------
| Sistema operativo |
------------------------
| Hardware |
------------------------

De esta manera, únicamente es posible ejecutar un único sistema operativo. Para poder ejecutar más de un sistema operativo vamos a emplear un software denominado máquina virtual que abstrae los detalles del hardware.

Según el tipo de máquina virtual (o '''hypervisor''' como se conoce en inglés):

* Tipo 2: Se trata de un proceso de espacio de usuario que simula en software todos los aspectos propios del hardware.

----------------
| P1 | P2 | P3 |
---------------|
| SO huésped |
----------------------------
| MV | Px | ... |
----------------------------
| SO anfitrión |
----------------------------
| Hardware |
----------------------------

Como proceso de espacio de usuario convencional, la máquina virtual emplea la API de llamadas al sistema operativo para solicitar recursos al sistema operativo.

Existen técnicas de paravirtualización, que permiten al sistema operativo huésped acceder de manera directa a recursos del sistema operativo anfitrión.

Permite la ejecución de diferentes sistemas operativos

Ejemplo: VirtualPC, VirtualBox, VMware.

* Tipo 1:

----------------------
| P1 | P2 | PX | PY |
----------------------
| SO1 | SO2 |
----------------------
| MV |
----------------------
| Hardware |
----------------------

La máquina virtual se trata de una especie de sistema operativo de sistemas operativos.

No permite la ejecución de diferentes sistemas operativos.

Ejemplo: MS-Hypervisor.

[[Ejercicios_3 | Ejercicios]]

[[Multiprogramación | 4.1 Multiprogramación]]

Virtualización

2016-10-16T18:46:55Z

Enrloport:

Llamadas al sistema

2016-10-16T18:45:26Z

Enrloport: /* El punto de entrada */

= 2.7. Llamadas al sistema =

== Definición de llamada al sistema ==

Una llamada al sistema es un método o función que puede invocar un proceso para solicitar un cierto servicio al sistema operativo. Dado que el acceso a ciertos recursos del sistema requieren la ejecución de código en modo privilegiado, el sistema operativo ofrece un conjunto de métodos o funciones que el programa puede emplear para acceder a dichos recursos. En otras palabras, el sistema operativo actúa como intermediario, ofreciendo una interfaz de programación (API) que el programa puede usar en cualquier momento para solicitar recursos gestionados por el sistema operativo.

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.
* '''open''', que es usada para obtener un descriptor de un fichero del sistema, ese fichero suele pasarse a write.

Todo sistema operativo ofrece un conjunto de llamadas al sistema. En el caso de Linux 3.0, se ofrecen un total de 345 llamadas al sistema. En esta [http://syscalls.kernelgrok.com/ lista] se encuentran un gran número de ellas.

Toda llamada al sistema se identifica de manera unívoca mediante un valor numérico que no debe ser modificado a lo largo de la vida del sistema operativo para evitar que se rompa la compatibilidad hacia atrás.

El siguiente ejemplo muestra en un ejemplo en C la invocación de las llamadas al sistema '''time''' y '''write'''.

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

int main(void)
{
uint64_t segundos;

segundos = time(NULL);
write(stdout, "Segundos desde 1970: %d", segundos);1
}
</source>

=== Familias de llamadas al sistema operativo: POSIX y WIN32/64 ===

Las dos familias de APIs estandarizas más importantes son:

* [http://es.wikipedia.org/wiki/POSIX POSIX].
* WIN32/64, empleada en los sistemas operativos de tipo-Windows. Además, existen emuladores como '''Wine''' que también las implementan.

== Implementación de llamadas 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 [[Gestión_de_Entrada/Salida|interrupción]] por software cuyo tratamiento es realizado por la rutina ''dispatcher''. Dicha rutina se encarga del tratamiento de la interrupción por software número 80.

'''Ejemplo de llamadas al sistema de Linux (64 bits):''' http://blog.rchapman.org/posts/Linux_System_Call_Table_for_x86_64/

[http://cs.lmu.edu/~ray/notes/linuxsyscalls/ Implementación de llamadas al sistema en Linux (32 y 64 bit)]

== 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.

Tiene un comportamiento sincronizado, cuando recibe una llamada se la pasa al sistema operativo y hasta que no recibe respuesta no atiende otra llamada.

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.

Lo ideal es que sean compatibles a lo largo del tiempo (aunque Windows normalmente no lo respeta).

[[Ejercicios_fundamentos_Sistemas_Operativos | Ejercicios]]

[[Modelos_de_Diseño_de_Sistemas_Operativos | 3.1 Modelos de diseño de Sistemas Operativos]]

Modelos de Diseño de Sistemas Operativos

2016-10-16T18:43:39Z

Enrloport:

= 3.1. Modelos de Diseño de SSOO =

== Modos de operación del procesador ==

Para entender los modelos de diseño de los sistemas operativos, tenemos que hacer referencia a los modos de ejecución del procesador. El modo de ejecución del procesador indica qué conjunto de instrucciones y a qué recursos del procesador se puede acceder en un cierto instante de tiempo.

En la actualidad, un procesador ofrece como mínimo dos modos de operación(ejecución) que son:

* '''Modo privilegiado'''(supervisor), que permite la ejecución de todo el conjunto de instrucciones que ofrece el procesador (no tiene ninguna relación con el modo "root" o administrador de algunos sistemas operativos).
* '''Modo no privilegiado'''(usuario), que tiene algunas restricciones de acceso a aspectos del procesador o de ejecución de instrucciones.

== Núcleo del sistema operativo ==

El núcleo del sistema operativo, también conocido por la terminología inglesa ''kernel'', es la parte más esencial del sistema operativo. Se trata de la capa visible del software más baja del sistema que provee y gestiona los recursos del sistema de forma segura a través de las llamadas al sistema.

El núcleo de un sistema operativo suele operar en modo privilegiado. Al operar en dicho modo un error de programación en el núcleo del sistema operativo puede resultar en un error fatal del cual el sistema sólo puede recuperarse mediante el reinicio del sistema. A tal error fatal también se le conoce en los sistemas operativos UNIX por la locución inglesa ''[http://es.wikipedia.org/wiki/Kernel_panic kernel panic]'' y en los sistemas operativos Windows por el nombre de ''[http://www.google.es/url?sa=t&source=web&cd=1&ved=0CCwQFjAA&url=http%3A%2F%2Fes.wikipedia.org%2Fwiki%2FPantalla_azul_de_la_muerte&ei=s02WTqvCCMjHtAaxuJyBBA&usg=AFQjCNE2tZra15VdohxjrhSogTQZOVedKg Pantallazo azul o BSOD]''.

== Tipos de Sistemas Operativos ==

Los sistemas operativos se pueden clasificar en base a la cantidad de funcionalidad implementada en su núcleo. En general distinguimos dos tipos de sistemas operativos:

* '''Monolíticos:''' son núcleos de gran tamaño (muchas líneas de código) con un alto número de funcionalidades, las cuales normalmente son compiladas junto al núcleo en el mismo momento.
* '''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. El resto de funcionalidades son añadidas mediante la adición de módulos externos al núcleo, lo que les proporciona flexibilidad y facilidad de ampliación en detrimento del desempeño necesario para la gestión dinámica de éstos.
* '''Pico/Nanonúcleos:''' se puede considerar un subtipo de Micronúcleo, son núcleos muy pequeños y flexibles, incluso mas pequeños que los Micronúcleos. Se usan en sistemas muy específicos, como satélites, en los que ya se sabe los procesos que se van a realizar. Son muy fiables.

No obstante, existen tipologías híbridas o que acentúan algunos aspectos, que también detallamos en esta sección.

[[Archivo:OS-structure2b(EDITADO).svg‎ |880px| Comparativa de distribución de funcionalidades entre distintos tipos de SO]]

=== Sistemas operativos Monolíticos ===

Los sistema operativos monolíticos se caracterizan por emplear un núcleo que implementa la planificación de procesos, el sistema de comunicación de procesos, el sistema de sincronizacion de procesos, la administración de la memoria principal, la administración de ficheros y la gestión de los dispositivos de entrada/salida. Por tanto, a mayor funcionalidad implementada en el núcleo, mayor número de líneas de código que se ejecutan en modo privilegiado.

Los sistemas operativos monolíticos son los predominantes hoy día, algunos ejemplos son:

* Sistemas operativos UNIX, tales como FreeBSD, NetBSD y OpenBSD.
* Sistemas operativos GNU/Linux.
* DOS, tales como MS-DOS y DR-DOS.

Como inconveniente, al emplear un núcleo que incluye gran parte de las funcionalidades básicas del sistema operativo, dispone de un alto número de líneas de código ejecutándose en modo privilegiado. Por ello, un error de programación en el núcleo puede provocar un ''kernel panic''. Además el hecho de añadir nuevas funcionalidades provocaría una nueva recompilación del núcleo llevando a reiniciar el sistema para que se apliquen los nuevos cambios.

Como principal ventaja, los sistemas operativo monolíticos ofrecen un alto rendimiento puesto que las peticiones entre los diferentes componentes se reducen a invocaciones de funciones.

=== Sistemas operativos Micronúcleo ===

También conocidos como sistemas operativos exokernel o exonúcleo, se caracterizan por disponer de un núcleo que implementa únicamente:

* Planificación de procesos
* Mecanismo de comunicación entre procesos
* Gestión de interrupciones

Además, existen procesos servidores que están fuera del núcleo, que se ejecutan en modo no privilegiado del procesador, y que implementan la:

* Administración de memoria principal
* Administración de ficheros
* Gestión de dispositivos de entrada/salida.

Siguiendo este esquema, cuando un proceso cualquiera solicita un servicio a través de una llamada al sistema, el micronúcleo canaliza la petición al proceso servidor correspondiente. Dicha comunicación se realiza mediante mensajería.

La principal ventaja de los sistemas operativos micronúcleo es que, al ejecutar menos líneas de código en modo privilegiado, de manera intuitiva son más fiables. Otras ventajas son que se garantiza el aislamiento de las partes que están fuera del núcleo, como los módulos son independientes unos de otros, si cae alguno de ello los demás no se ven afectados y pueden seguir funcionando.

Sin embargo, el principal problema que presentan es el rendimiento, puesto que cualquier petición requiere mensajería, que lleva consigo un coste extra debido a la construcción de los mensajes, el reparto y la interpretación. Son estos problemas relacionados con el rendimiento los que hacen que no existan sistemas operativos micronúcleo desplegables en productivo, a excepción de Minix 2, que tiene propósitos educativos. Otro ejemplo de micronúcleo es Symbian OS.

=== Sistemas operativos Híbridos ===

Los núcleos híbridos se encuentran entre los monolíticos y los micronúcleo. La mayoría de sistemas operativos modernos pertenecen a esta categoría, siendo el más popular Microsoft Windows. XNU, el núcleo de Mac OS X, también es un micronúcleo modificado, debido a la inclusión de código del núcleo de FreeBSD en el núcleo basado en Mach. DragonFlyBSD es el primer sistema BSD que adopta una arquitectura de núcleo híbrido sin basarse en Mach.

Algunos ejemplos de núcleos híbridos:

* Microsoft Windows NT, usado en todos los sistemas que usan el código base de Windows NT
* XNU (usado en Mac OS X)
* DragonFlyBSD
* ReactOS

Hay gente que confunde el término «núcleo híbrido» con los núcleos monolíticos que pueden cargar módulos después del arranque, lo que es un error. «Híbrido» implica que el núcleo en cuestión usa conceptos de arquitectura o mecanismos tanto del diseño monolítico como del micronúcleo, específicamente el paso de mensajes y la ejecución de ciertos componentes del sistema operativo en espacio de usuario.

=== Sistemas en estratos (por capas).===

El sistema en estratos “capas” consiste en organizar el sistema operativo como una jerarquía de capas, cada una construida sobre la inmediata inferior. Cada estrato desarrolla completamente una actividad del sistema.

Algunos ejemplos de sistemas en estratos:

* THE (Technishe Hogeschool Eindhoven) Dijkstra 1968 sistema de procesamiento por lotes.
Estratos:
5.) Proceso operador del sistema.
4.) Procesos de los usuarios.
3.) Control de Entrada/Salida.
2.) Comunicación proceso-consola.
1.) Administración de la memoria y del disco.
0.) Asignación del procesador y multiprogramación.
* MULTICS (Multiplexed Information and Computing Service) anillos concéntricos alrededor del hardware, donde los internos son más privilegiados que los externos.
[[Archivo:Anillos.jpg‎]]

--[[Usuario:Ricjimode|Ricjimode]] ([[Usuario discusión:Ricjimode|discusión]]) 20:29 27 ene 2015 (CET)

== Otro material a consultar ==

El estudiante puede encontrar el siguiente material de interés para complementar sus conocimientos:

* Debate entre Linus Torvalds, creador del núcleo Linux, que sigue el paradigma monolítico y Andrew S. Tanembaum, creador de Minux, que sigue el modelo micronúcleo: http://oreilly.com/catalog/opensources/book/appa.html (en inglés).

[[Virtualización | 3.2 Virtualización]]

Llamadas al sistema

2016-10-16T18:36:11Z

Enrloport: /* El dispatcher */

= 2.7. Llamadas al sistema =

== Definición de llamada al sistema ==

Una llamada al sistema es un método o función que puede invocar un proceso para solicitar un cierto servicio al sistema operativo. Dado que el acceso a ciertos recursos del sistema requieren la ejecución de código en modo privilegiado, el sistema operativo ofrece un conjunto de métodos o funciones que el programa puede emplear para acceder a dichos recursos. En otras palabras, el sistema operativo actúa como intermediario, ofreciendo una interfaz de programación (API) que el programa puede usar en cualquier momento para solicitar recursos gestionados por el sistema operativo.

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.
* '''open''', que es usada para obtener un descriptor de un fichero del sistema, ese fichero suele pasarse a write.

Todo sistema operativo ofrece un conjunto de llamadas al sistema. En el caso de Linux 3.0, se ofrecen un total de 345 llamadas al sistema. En esta [http://syscalls.kernelgrok.com/ lista] se encuentran un gran número de ellas.

Toda llamada al sistema se identifica de manera unívoca mediante un valor numérico que no debe ser modificado a lo largo de la vida del sistema operativo para evitar que se rompa la compatibilidad hacia atrás.

El siguiente ejemplo muestra en un ejemplo en C la invocación de las llamadas al sistema '''time''' y '''write'''.

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

int main(void)
{
uint64_t segundos;

segundos = time(NULL);
write(stdout, "Segundos desde 1970: %d", segundos);1
}
</source>

=== Familias de llamadas al sistema operativo: POSIX y WIN32/64 ===

Las dos familias de APIs estandarizas más importantes son:

* [http://es.wikipedia.org/wiki/POSIX POSIX].
* WIN32/64, empleada en los sistemas operativos de tipo-Windows. Además, existen emuladores como '''Wine''' que también las implementan.

== Implementación de llamadas 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 [[Gestión_de_Entrada/Salida|interrupción]] por software cuyo tratamiento es realizado por la rutina ''dispatcher''. Dicha rutina se encarga del tratamiento de la interrupción por software número 80.

'''Ejemplo de llamadas al sistema de Linux (64 bits):''' http://blog.rchapman.org/posts/Linux_System_Call_Table_for_x86_64/

[http://cs.lmu.edu/~ray/notes/linuxsyscalls/ Implementación de llamadas al sistema en Linux (32 y 64 bit)]

== 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.

Tiene un comportamiento sincronizado, cuando recibe una llamada se la pasa al sistema operativo y hasta que no recibe respuesta no atiende otra llamada.

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.

Lo ideal es que sean compatibles a lo largo del tiempo (aunque Windows normalmente no lo respeta).

[[Modelos_de_Diseño_de_Sistemas_Operativos | 3.1 Modelos de diseño de Sistemas Operativos]]

Llamadas al sistema

2016-10-16T18:19:52Z

Enrloport: /* Familias de llamadas al sistemas operativo: POSIX y WIN32/64 */

= 2.7. Llamadas al sistema =

== Definición de llamada al sistema ==

Una llamada al sistema es un método o función que puede invocar un proceso para solicitar un cierto servicio al sistema operativo. Dado que el acceso a ciertos recursos del sistema requieren la ejecución de código en modo privilegiado, el sistema operativo ofrece un conjunto de métodos o funciones que el programa puede emplear para acceder a dichos recursos. En otras palabras, el sistema operativo actúa como intermediario, ofreciendo una interfaz de programación (API) que el programa puede usar en cualquier momento para solicitar recursos gestionados por el sistema operativo.

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.
* '''open''', que es usada para obtener un descriptor de un fichero del sistema, ese fichero suele pasarse a write.

Todo sistema operativo ofrece un conjunto de llamadas al sistema. En el caso de Linux 3.0, se ofrecen un total de 345 llamadas al sistema. En esta [http://syscalls.kernelgrok.com/ lista] se encuentran un gran número de ellas.

Toda llamada al sistema se identifica de manera unívoca mediante un valor numérico que no debe ser modificado a lo largo de la vida del sistema operativo para evitar que se rompa la compatibilidad hacia atrás.

El siguiente ejemplo muestra en un ejemplo en C la invocación de las llamadas al sistema '''time''' y '''write'''.

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

int main(void)
{
uint64_t segundos;

segundos = time(NULL);
write(stdout, "Segundos desde 1970: %d", segundos);1
}
</source>

=== Familias de llamadas al sistema operativo: POSIX y WIN32/64 ===

Las dos familias de APIs estandarizas más importantes son:

* [http://es.wikipedia.org/wiki/POSIX POSIX].
* WIN32/64, empleada en los sistemas operativos de tipo-Windows. Además, existen emuladores como '''Wine''' que también las implementan.

== Implementación de llamadas 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 [[Gestión_de_Entrada/Salida|interrupción]] por software cuyo tratamiento es realizado por la rutina ''dispatcher''. Dicha rutina se encarga del tratamiento de la interrupción por software número 80.

'''Ejemplo de llamadas al sistema de Linux (64 bits):''' http://blog.rchapman.org/posts/Linux_System_Call_Table_for_x86_64/

[http://cs.lmu.edu/~ray/notes/linuxsyscalls/ Implementación de llamadas al sistema en Linux (32 y 64 bit)]

== 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.

Tiene un comportamiento sincronizado, cuando recibe una llamada y se la pasa al sistema operativo hasta que no recibe respuesta no atiende otra llamada.

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.

Lo ideal es que sean compatibles a lo largo del tiempo (aunque Windows normalmente no lo respeta).

[[Modelos_de_Diseño_de_Sistemas_Operativos | 3.1 Modelos de diseño de Sistemas Operativos]]

Llamadas al sistema

2016-10-16T18:02:42Z

Enrloport: /* El punto de entrada */

= 2.7. Llamadas al sistema =

== Definición de llamada al sistema ==

Una llamada al sistema es un método o función que puede invocar un proceso para solicitar un cierto servicio al sistema operativo. Dado que el acceso a ciertos recursos del sistema requieren la ejecución de código en modo privilegiado, el sistema operativo ofrece un conjunto de métodos o funciones que el programa puede emplear para acceder a dichos recursos. En otras palabras, el sistema operativo actúa como intermediario, ofreciendo una interfaz de programación (API) que el programa puede usar en cualquier momento para solicitar recursos gestionados por el sistema operativo.

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.
* '''open''', que es usada para obtener un descriptor de un fichero del sistema, ese fichero suele pasarse a write.

Todo sistema operativo ofrece un conjunto de llamadas al sistema. En el caso de Linux 3.0, se ofrecen un total de 345 llamadas al sistema. En esta [http://syscalls.kernelgrok.com/ lista] se encuentran un gran número de ellas.

Toda llamada al sistema se identifica de manera unívoca mediante un valor numérico que no debe ser modificado a lo largo de la vida del sistema operativo para evitar que se rompa la compatibilidad hacia atrás.

El siguiente ejemplo muestra en un ejemplo en C la invocación de las llamadas al sistema '''time''' y '''write'''.

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

int main(void)
{
uint64_t segundos;

segundos = time(NULL);
write(stdout, "Segundos desde 1970: %d", segundos);1
}
</source>

=== Familias de llamadas al sistemas operativo: POSIX y WIN32/64 ===

Las dos familias de APIs estandarizas más importantes son:

* [http://es.wikipedia.org/wiki/POSIX POSIX].
* WIN32/64, empleada en los sistemas operativos de tipo-Windows. Además, existen emuladores como '''Wine''' que también las implementan.

== Implementación de llamadas 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 [[Gestión_de_Entrada/Salida|interrupción]] por software cuyo tratamiento es realizado por la rutina ''dispatcher''. Dicha rutina se encarga del tratamiento de la interrupción por software número 80.

'''Ejemplo de llamadas al sistema de Linux (64 bits):''' http://blog.rchapman.org/posts/Linux_System_Call_Table_for_x86_64/

[http://cs.lmu.edu/~ray/notes/linuxsyscalls/ Implementación de llamadas al sistema en Linux (32 y 64 bit)]

== 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.

Tiene un comportamiento sincronizado, cuando recibe una llamada y se la pasa al sistema operativo hasta que no recibe respuesta no atiende otra llamada.

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.

Lo ideal es que sean compatibles a lo largo del tiempo (aunque Windows normalmente no lo respeta).

[[Modelos_de_Diseño_de_Sistemas_Operativos | 3.1 Modelos de diseño de Sistemas Operativos]]

Llamadas al sistema

2016-10-16T17:59:53Z

Enrloport: /* El punto de entrada */

= 2.7. Llamadas al sistema =

== Definición de llamada al sistema ==

Una llamada al sistema es un método o función que puede invocar un proceso para solicitar un cierto servicio al sistema operativo. Dado que el acceso a ciertos recursos del sistema requieren la ejecución de código en modo privilegiado, el sistema operativo ofrece un conjunto de métodos o funciones que el programa puede emplear para acceder a dichos recursos. En otras palabras, el sistema operativo actúa como intermediario, ofreciendo una interfaz de programación (API) que el programa puede usar en cualquier momento para solicitar recursos gestionados por el sistema operativo.

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.
* '''open''', que es usada para obtener un descriptor de un fichero del sistema, ese fichero suele pasarse a write.

Todo sistema operativo ofrece un conjunto de llamadas al sistema. En el caso de Linux 3.0, se ofrecen un total de 345 llamadas al sistema. En esta [http://syscalls.kernelgrok.com/ lista] se encuentran un gran número de ellas.

Toda llamada al sistema se identifica de manera unívoca mediante un valor numérico que no debe ser modificado a lo largo de la vida del sistema operativo para evitar que se rompa la compatibilidad hacia atrás.

El siguiente ejemplo muestra en un ejemplo en C la invocación de las llamadas al sistema '''time''' y '''write'''.

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

int main(void)
{
uint64_t segundos;

segundos = time(NULL);
write(stdout, "Segundos desde 1970: %d", segundos);1
}
</source>

=== Familias de llamadas al sistemas operativo: POSIX y WIN32/64 ===

Las dos familias de APIs estandarizas más importantes son:

* [http://es.wikipedia.org/wiki/POSIX POSIX].
* WIN32/64, empleada en los sistemas operativos de tipo-Windows. Además, existen emuladores como '''Wine''' que también las implementan.

== Implementación de llamadas 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 [[Gestión_de_Entrada/Salida|interrupción]] por software cuyo tratamiento es realizado por la rutina ''dispatcher''. Dicha rutina se encarga del tratamiento de la interrupción por software número 80.

'''Ejemplo de llamadas al sistema de Linux (64 bits):''' http://blog.rchapman.org/posts/Linux_System_Call_Table_for_x86_64/

[http://cs.lmu.edu/~ray/notes/linuxsyscalls/ Implementación de llamadas al sistema en Linux (32 y 64 bit)]

== 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.

Tiene un comportamiento sincronizado, cuando recibe una llamada y se la pasa al sistema operativo hasta que no recibe respuesta no atiende otra llamada.

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.

Lo ideal es que sean compatibles a lo largo del tiempo (aunque Windows normalmente no lo respeta).

[[Modelos de diseño de SSOO | 3.1 Modelos de diseño de SSOO]]

Llamadas al sistema

2016-10-16T17:58:25Z

Enrloport: /* El punto de entrada */

= 2.7. Llamadas al sistema =

== Definición de llamada al sistema ==

Una llamada al sistema es un método o función que puede invocar un proceso para solicitar un cierto servicio al sistema operativo. Dado que el acceso a ciertos recursos del sistema requieren la ejecución de código en modo privilegiado, el sistema operativo ofrece un conjunto de métodos o funciones que el programa puede emplear para acceder a dichos recursos. En otras palabras, el sistema operativo actúa como intermediario, ofreciendo una interfaz de programación (API) que el programa puede usar en cualquier momento para solicitar recursos gestionados por el sistema operativo.

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.
* '''open''', que es usada para obtener un descriptor de un fichero del sistema, ese fichero suele pasarse a write.

Todo sistema operativo ofrece un conjunto de llamadas al sistema. En el caso de Linux 3.0, se ofrecen un total de 345 llamadas al sistema. En esta [http://syscalls.kernelgrok.com/ lista] se encuentran un gran número de ellas.

Toda llamada al sistema se identifica de manera unívoca mediante un valor numérico que no debe ser modificado a lo largo de la vida del sistema operativo para evitar que se rompa la compatibilidad hacia atrás.

El siguiente ejemplo muestra en un ejemplo en C la invocación de las llamadas al sistema '''time''' y '''write'''.

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

int main(void)
{
uint64_t segundos;

segundos = time(NULL);
write(stdout, "Segundos desde 1970: %d", segundos);1
}
</source>

=== Familias de llamadas al sistemas operativo: POSIX y WIN32/64 ===

Las dos familias de APIs estandarizas más importantes son:

* [http://es.wikipedia.org/wiki/POSIX POSIX].
* WIN32/64, empleada en los sistemas operativos de tipo-Windows. Además, existen emuladores como '''Wine''' que también las implementan.

== Implementación de llamadas 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 [[Gestión_de_Entrada/Salida|interrupción]] por software cuyo tratamiento es realizado por la rutina ''dispatcher''. Dicha rutina se encarga del tratamiento de la interrupción por software número 80.

'''Ejemplo de llamadas al sistema de Linux (64 bits):''' http://blog.rchapman.org/posts/Linux_System_Call_Table_for_x86_64/

[http://cs.lmu.edu/~ray/notes/linuxsyscalls/ Implementación de llamadas al sistema en Linux (32 y 64 bit)]

== 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.

Tiene un comportamiento sincronizado, cuando recibe una llamada y se la pasa al sistema operativo hasta que no recibe respuesta no atiende otra llamada.

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.

Lo ideal es que sean compatibles a lo largo del tiempo (aunque Windows normalmente no lo respeta).

[[Modelos de diseño de sistemas operativos | 3.1 Modelos de diseño de sistemas operativos]]

Llamadas al sistema

2016-10-16T17:56:19Z

Enrloport:

= 2.7. Llamadas al sistema =

== Definición de llamada al sistema ==

Una llamada al sistema es un método o función que puede invocar un proceso para solicitar un cierto servicio al sistema operativo. Dado que el acceso a ciertos recursos del sistema requieren la ejecución de código en modo privilegiado, el sistema operativo ofrece un conjunto de métodos o funciones que el programa puede emplear para acceder a dichos recursos. En otras palabras, el sistema operativo actúa como intermediario, ofreciendo una interfaz de programación (API) que el programa puede usar en cualquier momento para solicitar recursos gestionados por el sistema operativo.

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.
* '''open''', que es usada para obtener un descriptor de un fichero del sistema, ese fichero suele pasarse a write.

Todo sistema operativo ofrece un conjunto de llamadas al sistema. En el caso de Linux 3.0, se ofrecen un total de 345 llamadas al sistema. En esta [http://syscalls.kernelgrok.com/ lista] se encuentran un gran número de ellas.

Toda llamada al sistema se identifica de manera unívoca mediante un valor numérico que no debe ser modificado a lo largo de la vida del sistema operativo para evitar que se rompa la compatibilidad hacia atrás.

El siguiente ejemplo muestra en un ejemplo en C la invocación de las llamadas al sistema '''time''' y '''write'''.

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

int main(void)
{
uint64_t segundos;

segundos = time(NULL);
write(stdout, "Segundos desde 1970: %d", segundos);1
}
</source>

=== Familias de llamadas al sistemas operativo: POSIX y WIN32/64 ===

Las dos familias de APIs estandarizas más importantes son:

* [http://es.wikipedia.org/wiki/POSIX POSIX].
* WIN32/64, empleada en los sistemas operativos de tipo-Windows. Además, existen emuladores como '''Wine''' que también las implementan.

== Implementación de llamadas 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 [[Gestión_de_Entrada/Salida|interrupción]] por software cuyo tratamiento es realizado por la rutina ''dispatcher''. Dicha rutina se encarga del tratamiento de la interrupción por software número 80.

'''Ejemplo de llamadas al sistema de Linux (64 bits):''' http://blog.rchapman.org/posts/Linux_System_Call_Table_for_x86_64/

[http://cs.lmu.edu/~ray/notes/linuxsyscalls/ Implementación de llamadas al sistema en Linux (32 y 64 bit)]

== 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.

Tiene un comportamiento sincronizado, cuando recibe una llamada y se la pasa al sistema operativo hasta que no recibe respuesta no atiende otra llamada.

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.

Lo ideal es que sean compatibles a lo largo del tiempo (aunque Windows normalmente no lo respeta).

[[Ejercicios | 2.8 Ejercicios]]

Llamadas al sistema

2016-10-16T17:55:04Z

Enrloport:

= 2.7. Llamadas al sistema =

== Definición de llamada al sistema ==

Una llamada al sistema es un método o función que puede invocar un proceso para solicitar un cierto servicio al sistema operativo. Dado que el acceso a ciertos recursos del sistema requieren la ejecución de código en modo privilegiado, el sistema operativo ofrece un conjunto de métodos o funciones que el programa puede emplear para acceder a dichos recursos. En otras palabras, el sistema operativo actúa como intermediario, ofreciendo una interfaz de programación (API) que el programa puede usar en cualquier momento para solicitar recursos gestionados por el sistema operativo.

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.
* '''open''', que es usada para obtener un descriptor de un fichero del sistema, ese fichero suele pasarse a write.

Todo sistema operativo ofrece un conjunto de llamadas al sistema. En el caso de Linux 3.0, se ofrecen un total de 345 llamadas al sistema. En esta [http://syscalls.kernelgrok.com/ lista] se encuentran un gran número de ellas.

Toda llamada al sistema se identifica de manera unívoca mediante un valor numérico que no debe ser modificado a lo largo de la vida del sistema operativo para evitar que se rompa la compatibilidad hacia atrás.

El siguiente ejemplo muestra en un ejemplo en C la invocación de las llamadas al sistema '''time''' y '''write'''.

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

int main(void)
{
uint64_t segundos;

segundos = time(NULL);
write(stdout, "Segundos desde 1970: %d", segundos);1
}
</source>

=== Familias de llamadas al sistemas operativo: POSIX y WIN32/64 ===

Las dos familias de APIs estandarizas más importantes son:

* [http://es.wikipedia.org/wiki/POSIX POSIX].
* WIN32/64, empleada en los sistemas operativos de tipo-Windows. Además, existen emuladores como '''Wine''' que también las implementan.

== Implementación de llamadas 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 [[Gestión_de_Entrada/Salida|interrupción]] por software cuyo tratamiento es realizado por la rutina ''dispatcher''. Dicha rutina se encarga del tratamiento de la interrupción por software número 80.

'''Ejemplo de llamadas al sistema de Linux (64 bits):''' http://blog.rchapman.org/posts/Linux_System_Call_Table_for_x86_64/

[http://cs.lmu.edu/~ray/notes/linuxsyscalls/ Implementación de llamadas al sistema en Linux (32 y 64 bit)]

== 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.

Tiene un comportamiento sincronizado, cuando recibe una llamada y se la pasa al sistema operativo hasta que no recibe respuesta no atiende otra llamada.

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.

Lo ideal es que sean compatibles a lo largo del tiempo (aunque Windows normalmente no lo respeta).

[[Administración de memoria | 2.8 Administración de memoria]]

Conceptos básicos

2016-10-16T17:52:34Z

Enrloport: /* Fichero */

= 2.6. 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 o 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 de uno o más procesos 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)'''.

[[Llamadas al sistema |2.7 Llamadas al sistema]]

Conceptos básicos

2016-10-16T17:40:47Z

Enrloport: /* Procesos en sistemas operativos tipo Unix */

Conceptos básicos

2016-10-16T17:37:47Z

Enrloport:

= 2.6. 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 o 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)'''.

[[Llamadas al sistema |2.7 Llamadas al sistema]]

Conceptos básicos

2016-10-16T17:36:32Z

Enrloport:

= 2.6. 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 o 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)'''.

[[Interbloqueo |2.7 Interbloqueo]]

Componentes básicos de un sistema operativo

2016-10-16T17:34:42Z

Enrloport:

=2.5. 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:

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

[[Conceptos básicos|2.6 Conceptos básicos]]

Arranque del sistema

2016-10-16T17:14:23Z

Enrloport: /* Arranque de un sistema operativo */

==Arranque de un sistema operativo==

Un poco de historia:
* Inicialmente, las instrucciones se metían a mano desde un panel.
* Los equipos más grandes tenían las instrucciones en una ROM, las cuales se copiaban la RAM.
* Los equipos basados en microprocesadores tienen las instrucciones en una memoria junto a la BIOS. La ventaja de esto es que no hay que copiarlas a la RAM, el inconveniente es que dichas instrucciones ocupan memoria.

A partir de aquí, el proceso de arranque difiere, en ésta entrada trataremos el arranque de los equipos tipo PC.

Estos equipos, al ser de arquitectura abierta, no sólo contemplan la BIOS como su propia ROM, sino también dispositivos externos.

El arranque de un sistema operativo suele ser un proceso muy común hasta cierto punto, en el cual difieren en función del tipo de sistema.

1. Se inicia el procesador y se prepara para ejecutar instrucciones, las condiciones iniciales son fijas.

2. Se ejecutan las primeras instrucciones.

3. Se inicia lo principal (comprobación de memoria, pantalla, teclado, reloj…).

4. Se inician los dispositivos adicionales con ROM propia. Se miran ciertas posiciones de memoria, y si no están vacías, la ROM principal salta ahí para iniciar el dispositivo (disco duro, disquete,…).

5. Se determina de dónde se cargará el SO. Para esto, la BIOS carga un pequeño programa que es el que inicia el SO.

En caso de que éste se inicie desde el disco duro, la BIOS consultará la posición 0 del disco, en la que se encuentra la tabla de particiones, donde se indica dónde está el programa de carga del SO, el cual se iniciará y continuará con el proceso de arranque.

6. Se carga la parte principal del sistema operativo.

7. Se inicia el sistema operativo.
* Se inician los elementos fundamentales del sistema operativo.
* Se inician los elementos fundamentales de lectura/escritura (drivers).
* Se comprueba el sistema de archivos.
* Se completan las pruebas y se carga el software adicional.
* Se arrancan los procesos necesarios del SO para que realice sus inicializaciones particulares.
* En ciertos casos, se inicia un archivo de órdenes que arranca los programas de servicios.

A partir de éste punto, se realiza una nueva división, en función de si el SO es interactivo sin identificación de usuario (MS-DOS, por ejemplo), si requiere identificación, si es por lotes sencillos o si es por lotes superior.

8a. Se lanza el intérprete de órdenes y/la interfaz gráfica.

8b. Se lanza un proceso de log-in por cada terminal, el cual se mantiene en espera hasta que se identifique correctamente, punto en el cual, se lanzará el intérprete y la UI (interfaz de usuario).

8c. Se pone en marcha la cola de trabajos.

8d. Se inicia sesión en la consola del operador y éste montará los dispositivos, fijará los criterios de funcionamiento…

[[Componentes básicos de un sistema operativo|2.5 Componentes básicos de un sistema operativo]]

Organización básica de un ordenador

2016-10-15T08:30:38Z

Enrloport:

Un ordenador está compuesto de los siguientes componentes básicos:

* Unidad de procesamiento (CPU). Dispone de juego de instrucciones básicas de bajo nivel (lenguaje ensamblador) definidas por el diseñador/fabricante. Por tanto, el juego de instrucciones y los parámetros que estas toman son diferentes según el tipo de procesador que se esté empleado. Algunos ejemplos de procesadores, son las familias Intel x86 y x86_64, ARM, SPARC y PowerPC, entre muchas otras.
* Memoria principal. Almacena el estado de la ejecución de los procesos, es decir, variables y estructuras de datos empleadas. Es una memoria volátil, por tanto, al dejar de suministrarseles energía, la información se desvanece.
* Dispositivos de entrada y salida. Son dispositivos que permiten recibir y enviar datos que pueden ser empleados por los programas en ejecución. Por ejemplo, teclado, ratón, disco duro magnético, tarjeta de red, tarjeta de vídeo, entre muchos otros.

En la arquitectura de Von Neumann, estos tres componentes se comunican a través de un único bus.

2.2. [[Modos de operación de la CPU|Modos de operación de la CPU]]