Wiki de Sistemas Operativos - Contribuciones del usuario [es]

Discos Magnéticos

2017-01-10T11:04:16Z

Edudellir: Deshecha la revisión 3408 de Edudellir (disc.)

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

Discos Magnéticos

2017-01-10T11:03:07Z

Edudellir: /* 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

Memoria virtual con multiprogramacion

2016-12-14T09:01:01Z

Edudellir: /* Modelo del conjunto de trabajo */

Cuando se aplican métodos de memoria virtual en sistemas multiprogramados, surgen nuevos problemas o elecciones de diseño.
==Criterios locales y globales==
A la hora de elegir página víctima, podemos elegirla entre las asignadas al proceso (criterio local), o entre todas las páginas del sistema (Criterio global).
*'''Criterio local:''' Mantiene constante el número de páginas de un proceso cargadas en memoria, y es más eficiente, al operar sólo con las páginas del proceso. Se plantea el problema de determinar el número inicial de marcos.
*'''Criterio global:''' La asignación dinámica de marcos se adapta a las necesidades de los procesos. Se plantea el problema de que el criterio de sustitución favorece al proceso activo, ya que un proceso inactivo puede encontrarse que cuando le llegue el turno, se encuentre sus páginas movidas a memoria.
*'''Criterio mixto:''' Tiene las ventajas de ambos criterios, ya que ante una sustitución, se aplica un criterio local, de manera que el algoritmo de sustitución opera sobre un conjunto menor de marcos, y de forma dinámica, se equilibra el número de marcos entre procesos.

==Modelo del conjunto de trabajo==
Es un modelo que sigue un criterio híbrido y define como conjunto de trabajo el rango de páginas con las que opera un proceso durante una fase de su ejecución, es decir, el conjunto de páginas que hay que mantener en memoria para que no se produzcan fallos de página mientras dure dicha fase. Por ejemplo, puede que al iniciarse un proceso, necesite un rango de 10 o 20 páginas, y que pasado un tiempo, se estabilice, usando únicamente 3 o 4. Su conjunto de trabajo es un rango de páginas que cambia a lo largo del tiempo.

El objetivo es evitar la hiperpaginación, es decir, la sobrecarga debida a un aumento de la frecuencia de fallos de página hasta que se produzca un fallo de página cada pocas instrucciones.

La estrategia tener como máxima la de no retirarle nunca a un proceso una página perteneciente a su conjunto de trabajo.

==Aplicación de frecuencia de fallos de páginas==
Ya que el sistema operativo no puede saber cuál es el conjunto de trabajo de un proceso, se sigue una estrategia aproximada: Asignar dinámicamente el número de marcos en función de la frecuencia de fallos de página, que se limita superior e inferiormente.

Así, nunca habrá procesos con un número excesivo de marcos (Aprovechamiento) ni con menos de los necesarios (Posible hiperpaginación)
==Métodos de reserva==
Una posible decisión de diseño es la de mantener siempre una lista de marcos libres, ya que la memoria virtual funciona mejor si hay marcos libres cuando se produce un fallo de página.

Un demonio de paginación se ejecuta periódicamente, para descargar páginas que no estén en uso aplicando algún criterio de sustitución.

Esta decisión de diseño es discutible en sistemas interactivos, ya que tras periodos de inactividad por parte del usuario, este se puede encontrar con una sobrecarga añadida en la reanudación, al haber muchos procesos cuyas páginas han sido descargadas.
==Carga de páginas por anticipado==
Para evitar fallos de página, se pueden cargar páginas antes de que hagan falta, aplicando criterios de:
*Localidad espacial: Al transferir una página, se transfieren también sus adyacentes.
*Conjuntos de trabajo: En caso de bloqueo, se anotan las páginas que supuestamente pertenecen al conjunto de trabajo, para que al reactivarlo, se carguen todas esas páginas. El sistema operativo Android es un ejemplo de administrador de memoria que aplica esta técnica.

Memoria virtual con multiprogramacion

2016-12-14T08:59:20Z

Edudellir: /* Modelo del conjunto de trabajo */

Cuando se aplican métodos de memoria virtual en sistemas multiprogramados, surgen nuevos problemas o elecciones de diseño.
==Criterios locales y globales==
A la hora de elegir página víctima, podemos elegirla entre las asignadas al proceso (criterio local), o entre todas las páginas del sistema (Criterio global).
*'''Criterio local:''' Mantiene constante el número de páginas de un proceso cargadas en memoria, y es más eficiente, al operar sólo con las páginas del proceso. Se plantea el problema de determinar el número inicial de marcos.
*'''Criterio global:''' La asignación dinámica de marcos se adapta a las necesidades de los procesos. Se plantea el problema de que el criterio de sustitución favorece al proceso activo, ya que un proceso inactivo puede encontrarse que cuando le llegue el turno, se encuentre sus páginas movidas a memoria.
*'''Criterio mixto:''' Tiene las ventajas de ambos criterios, ya que ante una sustitución, se aplica un criterio local, de manera que el algoritmo de sustitución opera sobre un conjunto menor de marcos, y de forma dinámica, se equilibra el número de marcos entre procesos.

==Modelo del conjunto de trabajo==
Es un modelo que sigue un criterio híbrido y define como conjunto de trabajo el rango de páginas con las que opera un proceso durante una fase de su ejecución, es decir, el conjunto de páginas que hay que mantener en memoria para que no se produzcan fallos de página. Por ejemplo, puede que al iniciarse un proceso, necesite un rango de 10 o 20 páginas, y que pasado un tiempo, se estabilice, usando únicamente 3 o 4. Su conjunto de trabajo es un rango de páginas que cambia a lo largo del tiempo.

El objetivo es evitar la hiperpaginación, es decir, la sobrecarga debida a un aumento de la frecuencia de fallos de página hasta que se produzca un fallo de página cada pocas instrucciones.

La estrategia tener como máxima la de no retirarle nunca a un proceso una página perteneciente a su conjunto de trabajo.

==Aplicación de frecuencia de fallos de páginas==
Ya que el sistema operativo no puede saber cuál es el conjunto de trabajo de un proceso, se sigue una estrategia aproximada: Asignar dinámicamente el número de marcos en función de la frecuencia de fallos de página, que se limita superior e inferiormente.

Así, nunca habrá procesos con un número excesivo de marcos (Aprovechamiento) ni con menos de los necesarios (Posible hiperpaginación)
==Métodos de reserva==
Una posible decisión de diseño es la de mantener siempre una lista de marcos libres, ya que la memoria virtual funciona mejor si hay marcos libres cuando se produce un fallo de página.

Un demonio de paginación se ejecuta periódicamente, para descargar páginas que no estén en uso aplicando algún criterio de sustitución.

Esta decisión de diseño es discutible en sistemas interactivos, ya que tras periodos de inactividad por parte del usuario, este se puede encontrar con una sobrecarga añadida en la reanudación, al haber muchos procesos cuyas páginas han sido descargadas.
==Carga de páginas por anticipado==
Para evitar fallos de página, se pueden cargar páginas antes de que hagan falta, aplicando criterios de:
*Localidad espacial: Al transferir una página, se transfieren también sus adyacentes.
*Conjuntos de trabajo: En caso de bloqueo, se anotan las páginas que supuestamente pertenecen al conjunto de trabajo, para que al reactivarlo, se carguen todas esas páginas. El sistema operativo Android es un ejemplo de administrador de memoria que aplica esta técnica.

Planificación en sistemas multiprocesadores

2016-12-04T11:36:44Z

Edudellir: /* 5.6 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

2016-12-04T10:29:30Z

Edudellir: /* 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]]

Criterios de planificación

2016-12-03T12:07:11Z

Edudellir: /* 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 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|

Hilos

2016-12-03T11:39:26Z

Edudellir: /* Ejemplo */

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

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

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

Veamos un ejemplo diseñado para un solo procesador:

[[Archivo:Uso_del_procesador_hilos.svg]]

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

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

Las principales ventajas del uso de hilos son:

*'''Menor penalización''' en cuanto a conmutación. Ya que sólo se produce un salto en la ejecución de código del proceso, no interviene el planificador de procesos.

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

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

= Ejemplo =

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

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

int a = 10;

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

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

int main(void)
{
pthread_t hilo1, hilo2;

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

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

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

[[Ejercicios_Procesos | Ejercicios]]

5.1.[[Planificación de procesos| La planificación de procesos]]

Llamadas al sistema

2016-12-03T11:38:31Z

Edudellir: /* 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]]

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

Virtualización

2016-10-22T17:53:14Z

Edudellir: /* Técnicas de virtualización */

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

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

Modelos de Diseño de Sistemas Operativos

2016-10-22T17:52:57Z

Edudellir: /* Otro material a consultar */

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

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

Llamadas al sistema

2016-10-22T17:52:32Z

Edudellir: /* El punto de entrada */

Conceptos básicos

2016-10-22T17:52:08Z

Edudellir: /* 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 organización en forma de árbol.

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)'''.

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

Componentes básicos de un sistema operativo

2016-10-22T17:51:45Z

Edudellir: /* 2.5. Componentes básicos de un Sistema Operativo */

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

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

Arranque del sistema

2016-10-22T17:51:27Z

Edudellir:

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

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

Interrupciones y excepciones

2016-10-22T17:50:59Z

Edudellir:

==Tipos de interrupciones y excepciones==

* Una interrupción por hardware es un mecanismo de comunicación entre el procesador y los dispositivos de E/S. Sirve para indicar que un dispositivo de E/S tiene datos pendientes de ser tratados. Las interrupciones por hardware evitan que el sistema operativo tenga que muestrear periódicamente el estado de los dispositivos de E/S, de manera que son ellos mismos los que indican que hay datos a ser tratados.

* Una interrupción por software, es un mecanismo de comunicación entre un proceso (que se ejecuta en modo usuario) y el sistema operativo (que se ejecuta en modo supervisor). El proceso emplea las interrupciones por software para notificar al sistema operativo que requiere de su intervención. Para lanzar una interrupción por software un proceso ejecuta la instrucción '''int''' seguida de un número de 16 bits que indica el tipo de interrupción por software. Por ejemplo, las llamadas al sistema en x86 se implementan mediante interrupciones por software, por medio de la instrucción '''int 0x80''' (Sin embargo, hoy día las arquitectura de procesadores viene con instrucciones especializadas para la invocación de llamadas al sistema, por tanto esta técnica ha caído en desuso).

Las excepciones son un tipo de interrupción por software que emplea el sistema operativo para indicar al proceso de un evento externo que debe ser tratado inmediatamente.

El tratamiento de interrupciones es prioritario, por tanto, en caso de interrupción se deja de ejecutar el proceso para dar paso al manejador de la interrupciones.

==Tratamiento de interrupciones y excepciones==

Cuando se produce una interrupción:

1. Almacena el estado de la ejecución del proceso en el Bloque de Control de procesos (PCB).

2. Se pasa la CPU a modo supervisor.

3. Se ejecuta el código del sistema operativo que realiza el tratamiento de la interrupción. Este decide la acción correspondiente dependiendo del tipo de interrupción.

4. Se devuelve el control de la ejecución al planificador del sistema operativo.

2.4.[[Arranque del sistema| Arranque del sistema]]

Hilos

2016-10-22T17:50:00Z

Edudellir:

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

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

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

Veamos un ejemplo diseñado para un solo procesador:

[[Archivo:Uso_del_procesador_hilos.svg]]

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

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

Las principales ventajas del uso de hilos son:

*'''Menor penalización''' en cuanto a conmutación. Ya que sólo se produce un salto en la ejecución de código del proceso, no interviene el planificador de procesos.

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

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

= Ejemplo =

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

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

int a = 10;

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

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

int main(void)
{
pthread_t hilo1, hilo2;

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

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

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

5.1.[[Planificación de procesos| La planificación de procesos]]

Hilos

2016-10-22T17:48:30Z

Edudellir: /* 3.5 Hilos */

Conmutación de procesos

2016-10-22T17:47:34Z

Edudellir:

La conmutación de procesos es la operación que consiste en retirar el procesador a un proceso para asignárselo a otro. La conmutación se produce por cuatro razones:

#Un proceso agota el tiempo máximo asignado al procesador, por tanto, se debe dar paso a otro proceso para garantizar que la multiprogramación es llevada a cabo apropiadamente.
#Un proceso está pendiente de un evento externo, por tanto, pasa a estado bloqueado haciendo uso de la llamada al sistema bloqueante. El planificador debe asignar el procesador a otro nuevo proceso de entre los que están en estado preparado.
#Que termine la ejecución del proceso en cuestión.
#Que haya una [[Gestión_de_Entrada/Salida|interrupción]] en la ejecución.

Los pasos que se siguen son los siguientes:

# Pasar a modo privilegiado.
# Guardar el contenido de los registros del hardware en el PCB (el llamado ''contexto de la ejecución'').
# Actualizar el estado del proceso en el PCB (el estado ha pasado de activo a bloqueado o preparado).
# Si se produjo una interrupción, atenderla.
# Seleccionar un nuevo proceso.
# Restaurar el contexto de ejecución del nuevo proceso seleccionado. En el caso de que el nuevo proceso no hubiese estado en el contexto de la ejecución deberá inicializarse.
# Pasar a modo no privilegiado.

[[Imagen:Asig2.png]]

El tiempo de conmutación se considera una penalizanción, ya que si realizamos muchas conmutaciones el rendimiento decrece y esto da al usuario la sensación de que sus actividades van a saltos. Para optimizar esto hay que evitar conmutaciones innecesarias, empleando para ello criterios de selección lo más eficientes posibles.

4.7.[[Hilos| Hilos]]

Bloque de control de procesos

2016-10-22T17:46:46Z

Edudellir:

Para llevar a cabo la gestión de un proceso, es necesario que el sistema operativo guarde cierta información necesaria. Para ello, existe un registro especial que se conoce como '''el bloque de control del proceso BCP, o PCB en inglés (Process Control Block)'''.

El BCP es creado por el Sistema operativo cada vez que aparece un nuevo proceso. Los procesos son conocidos para el sistema operativo y por tanto elegibles para competir por los recursos del sistema sólo cuando existe un BCP activo asociado a ellos. Cuando el programa termina, el BCP es eliminado para dejar espacio libre en el registro, y usarlo para almacenar otros BCP.

El bloque de control de procesos difiere mucho de un sistema a otros, pero existen contenidos comunes:

* '''Identificador del proceso:''' Identificar de forma unívoca al proceso en el sistema, generalmente se emplea un entero sin signo que se denomina PID (Process IDentifier)

* '''Estado del proceso para el planificador de procesos:''' preparado, activo o bloqueado.

* '''Contexto de la ejecución:''' valor de los registros del procesador, bits de estados, etc. Esto es, cada vez que se ejecuta el planificador y se realiza una [[Conmutación de procesos|conmutación de procesos]], la información sobre en qué lugar se encontraba la ejecución del proceso se encuentra guardada aquí, así como el lugar en el que se paró la ejecución del anterior proceso (cada una en su respectivo BCP).

* '''Aspectos relacionados con la administración de memoria:''' tales como el espacio de direcciones y la cantidad de memoria asignada a un proceso.

* '''Aspectos relacionados con la administración de ficheros:''' tales como los ficheros con los que el proceso está actualmente operando.

* '''Los procesadores en los que el proceso puede ejecutarse:''' en caso de soportar el sistema multiprocesador.

* '''En el caso de un sistema operativo tipo UNIX:''' el proceso padre de dicho proceso y la relación de procesos hijos.

* '''Estadísticas temporales:''' Tiempo de lanzamiento del proceso, tiempo en estado activo, etc.

En Linux, al PCB se le denomina ''Task Struct'', se puede consultar dicha estructura en:

http://lxr.linux.no/#linux+v2.6.37.2/include/linux/sched.h#L1182

http://lxr.linux.no/linux+v3.0.4/include/linux/sched.h#L1220

En el núcleo de Minix, al PCB se le denomina ''Process table'', puede consultarse su implementación en el siguiente enlace:

http://www.cise.ufl.edu/~cop4600/cgi-bin/lxr/http/source.cgi/kernel/proc.h

4.6.[[Conmutación de procesos| La conmutación de procesos]]

Comportamiento de los procesos

2016-10-22T17:45:55Z

Edudellir:

= Tipos de procesos =

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

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

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

[[Archivo:Procesos.jpg]]

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

4.5.[[Bloque de control de procesos| El bloque de control del proceso]]

Planificador de procesos

2016-10-22T17:44:23Z

Edudellir:

= ¿Qué es el planificador de procesos? =

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

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

El planificador de procesos tiene como funciones principales:

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

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

= Ejemplo =

Para la siguiente configuración de procesos:

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

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

[[Archivo:Procesos.jpg]]

4.4.[[Comportamiento de los procesos| El comportamiento de los procesos según el planificador]]

Estados de los procesos

2016-10-22T17:42:36Z

Edudellir: /* 3.2 Estados de los procesos */

= 3.2 Estados de los procesos =

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

== Diagrama de estados simplificado ==

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

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

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

[[Archivo:SSOO2.jpg]]

== Diagrama de Estados Ampliado ==
* '''En espera / Preparación''': Estado por el que pasan los procesos antes de pasar a estar preparados por primera vez. Los procesos, cuando comienzan a existir, no están preparados para comenzar a ejecutar instrucciones hasta que el sistema no ha llevado a cabo una serie de actividades. Una vez que el proceso está completamente cargado, ya se puede producir la primera transición al estado preparado.
* '''Terminado''': La transición de activo a este estado ocurre cuando el proceso realiza una llamada al sistema solicitando su propia terminación. En estas circunstancias, hay estructuras de datos correspondientes al proceso que no pueden ser liberadas hasta que el proceso padre del que está terminando recoja el código de terminación del mismo. Hasta que esto ocurra, estas estructuras se mantendrán y el proceso seguirá existiendo en estado terminado.
* '''Transición''': cuando se completa la operación que mantiene a un proceso en estado bloqueado termina, el proceso puede haber perdido parte de los recursos que necesita para proseguir su ejecución.

[[Archivo:SSOOProc.jpg]]

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

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

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

4.3.[[Planificador de procesos| El planificador de procesos]]

Multiprogramación

2016-10-22T17:41:13Z

Edudellir: /* La Multiprogramación */

= La Multiprogramación =

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

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

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

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

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

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

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

4.2.[[Estados de los procesos| Estados de los procesos]]

Llamadas al sistema

2016-10-22T17:31:03Z

Edudellir: /* 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]]

Componentes básicos de un sistema operativo

2016-10-22T16:50:56Z

Edudellir: /* 2.5. Componentes básicos de un Sistema Operativo */

Arranque del sistema

2016-10-22T16:50:40Z

Edudellir: /* 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]]

Modos de operación de la CPU

2016-10-22T16:46:54Z

Edudellir:

= 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 propia 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]]

Usuario:Edudellir

2016-10-22T16:44:51Z

Edudellir: Página creada con «edudellir@alum.us.es»

edudellir@alum.us.es

Qué es un Sistema operativo

2016-10-22T16:40:06Z

Edudellir: Enlace al siguiente apartado.

[[Archivo:Sistema Operativo.png|right]]
Un '''sistema operativo''' es la parte del '''software''' que se comunica directamente con el hardware, conociendo los detalles de bajo nivel que necesita para ello. Un sistema operativo puede ser de propósito general, como es Windows, Linux o Android, o bien puede ser de propósito específico, como puede ser el sistema operativo que usa un teléfono móvil para las telecomunicaciones, el de un coche o el de un satélite. Un dispositivo puede tener un sistema híbrido, contando con un sistema operativo de propósito general y otro de propósito específico, como sucede en los móviles.

En este curso solo estudiaremos los sistemas operativos de propósito general. Las utilidades y características de estos son las siguientes:
* '''Abstrae del hardware''': Esto hace posible que los programas desarrollados para el sistema operativo en cuestión funcionen en distintos dispositivos, sin conocer sus detalles específicos. Es el sistema operativo el que se encarga de comunicarlo con el hardware.

* '''Proporciona una biblioteca de métodos''': Estos métodos o funciones pueden ser usados por los programadores a la hora de desarrollar sus aplicaciones.

* '''Gestiona los recursos de manera equitativa''': Un sistema operativo debe encargarse de que los procesos progresen en tiempo de ejecución. Un solo procesador debe encargarse de un gran número de procesos simultáneamente, y no es posible hacerlo en paralelo. El sistema operativo los gestiona para que todos los procesos avancen de manera ecuánime.

* '''Debe consumir el mínimo de recursos''': Para que los procesos se realicen de la manera más rápida posible, el sistema operativo debe consumir los menos recursos posibles, de manera que la mayor parte de recursos se dedique a estos procesos.

* '''Sirve de interfaz para el usuario''': Un sistema operativo puede implementar múltiples interfaces.

1.2. [[Introducción histórica|Breve introducción histórica a los Sistemas Operativos]]