Wiki de Sistemas Operativos - Contribuciones del usuario [es]

Concurrencia de procesos

2016-01-26T07:54:48Z

Migestgom: /* Tipos de mecanismos de sincronización */

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

= El problema del productor y consumidor =

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

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

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

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

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

= Mecanismos de arbitraje =

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

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

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

= Programación concurrente =

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

Hay tres formas de interacción entre procesos cooperativos:

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

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

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

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

= Sección crítica =

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

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

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

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

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

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

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

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

= Tipos de mecanismos de sincronización =

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

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

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

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

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

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

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

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

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

e.printStackTrace();
}
}
};

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

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

e.printStackTrace();
}
}
};

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

e.printStackTrace();
}
}
};

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

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

}

</source>

Concurrencia de procesos

2016-01-26T07:49:00Z

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

Concurrencia de procesos

2016-01-26T07:46:43Z

Migestgom: /* Tipos de mecanismos de sincronización */

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

= El problema del productor y consumidor =

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

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

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

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

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

= Mecanismos de arbitraje =

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

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

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

= Programación concurrente =

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

Hay tres formas de interacción entre procesos cooperativos:

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

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

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

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

= Sección crítica =

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

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

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

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

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

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

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

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

= Tipos de mecanismos de sincronización =

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

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

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

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

== ¿Cómo provocar errores de concurrencia en Java? ==

Try it yourself :

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

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

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

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

e.printStackTrace();
}
}
};

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

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

e.printStackTrace();
}
}
};

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

e.printStackTrace();
}
}
};

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

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

}

</source>

Página Principal

2016-01-26T07:20:29Z

Migestgom: /* Novedades y noticias */

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

= Novedades y noticias =

* Los siguientes estudiantes han solicitado que se les revise sus contribuciones a la asignatura:

Sánchez Muñoz, Luis Manuel (luisanmun)
Utrilla Martín, Juan Carlos (juautrmar)
Ramos Castro, Eva (evaramcas1)
Martin Martin, Alejandro (alemarmar5)
Hidalgo Sanchez-Noriega, Daniel (danhidsan)
García Calero, Roberto (robgarcal)
López Muñoz, Juan Carlos (jualopmun2)
Miguel Esteban Gómez (migestgom)

Si no apareces en esta lista y enviáste el email antes del pasado viernes 22 de enero (fecha límite), contacta al profesor. --[[Usuario:Pneira|Pneira]] ([[Usuario discusión:Pneira|discusión]]) 17:43 23 ene 2016 (CET)

* [http://1984.lsi.us.es/~pablo/notas-ssoo-2015-2016.pdf Notas del primer, segundo, tercer y cuarto control de evaluación continua, incluida media] --[[Usuario:Pneira|Pneira]] ([[Usuario discusión:Pneira|discusión]]) 15:22 14 ene 2016 (CET)
* [http://1984.lsi.us.es/~pablo/ssoo-c3.pdf Notas del primer, segundo y tercer control de evaluación continua] --[[Usuario:Pneira|Pneira]] ([[Usuario discusión:Pneira|discusión]]) 08:42 7 ene 2016 (CET)
* [http://1984.lsi.us.es/~pablo/ssoo-c2.pdf Notas del primer y segundo control de evaluación continua] --[[Usuario:Pneira|Pneira]] ([[Usuario discusión:Pneira|discusión]]) 00:26 17 dic 2015 (CET)

= Unidades didácticas =

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

== Introducción a los Sistemas Operativos ==

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

== Fundamentos de Sistemas Operativos ==

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

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

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

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

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

== Concurrencia de procesos ==

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

== Interbloqueo ==

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

== Administración de memoria ==

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

== Memoria virtual ==

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

== Entrada/Salida ==

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

== Gestión L/E ==

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

== Administración de archivos ==

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

== Anexo ==

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

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

Xv6

2016-01-26T07:17:44Z

Migestgom: /* Enlaces de interés */

= Introducción a XV6 =

XV6 es un sistema operativo creado por el [http://web.mit.edu/ MIT] (Massachusetts Institute of Technology) con motivos educacionales y desarrollado en el 2006.
Este sistema operativo está basado en la versión 6 de UNIX y es una reimplementación de éste para la arquitectura de procesadores intel x86. Se trata de un sistema operativo monolítico escrito en el lenguaje de programación C. Además su interfaz de usuario por defecto es una interfaz de lineas de comando.

En los siguientes pasos aprenderemos a descargarlo e instalarlo y diferenciaremos las partes mas básicas de un SO estudiadas en teoría en el código de xv6.

= Instalación de QEMU en Linux Ubuntu =

Para instalar xv6 primero necesitaremos instalar [http://wiki.qemu.org/Main_Page QEMU], un emulador de código abierto capaz de emular nuestro sistema operativo. Podemos instalar QEMU de diferentes formas:

-Por terminal

-Por un gestor de paquetes.

'''Instalacion de QEMU por terminal:'''

En primer lugar abre un terminal y ejecuta el comando:

'''''sudo apt-get install qemu qemu-kvm libvirt-bin'''''

[[Archivo:Captura_instalacion_qemu.png]]

Introduce tu contraseña y el terminal te preguntará si deseas continuar con la
instalación, podrás ver los paquetes que se instalarán y el espacio necesario para la
instalación. Tras estos pasos ya habrás instalado QEMU en tu equipo.

'''Por paquetes:'''

Para empezar tienes que tener el gestor de paquetes Synaptic instalado (también sirven otros, pero este es muy bueno)
Una vez instalado Synaptic ábrelo y el buscar introduce "QEMU". Cuando el programa termine de buscar tienes que encontrar el paquete que se llama qemu-kvm, hacer doble click y posteriormente pulsar en "aplicar" que se encuentra en el menú de la parte superior. Una vez termine la instalación ya tendrás QEMU instalado.

[[Archivo:Qemu_synaptic.png]]

= Descarga e instalacion de XV6 =
Ahora que ya tenemos QEMU instalado podemos empezar a descargar xv6.

Para descargarlo es necesario tener '''''git''''' instalado.
Para ello introduce esto en el terminal:

'''''sudo apt-get install git'''''

Una vez instalado GIT descargaremos el sistema operativo del repositorio público. Ejecuntando el siguiente comando en terminal, descargaremos los archivos necesarios para la instalación de xv6:

'''''git clone https://michaelee@bitbucket.ort/michaelee/xv6.git'''''

[[Archivo:captura_clonacion_xv6.png]]

Aparecerá en tu carpeta personal una nueva carpeta con el código de xv6.
Ya tenemos el código de xv6, ahora toca emularlo.

Navegamos con el terminal hasta la carpeta recientemente creada.

[[Archivo:captura_compilacion_xv6.png]]

Una vez dentro escribimos '''''make''''', con este comando compilaremos el codigo clonado anteriormente. Una vez que haya terminado la compilación ejecutaremos el comando '''''make qemu-nox'''''. Se abrirá una nueva pantalla, lo que significa que ya tenemos xv6 emulado.

[[Archivo:captura_inicializacion_xv6.png]]

= Analizando XV6 =

A continuación veremos la sección del código de xv6 de cada una de las partes básicas de un sistema operativo vistas en teoría.

1- [[scheduler_xv6|Planificador de procesos]]

2- [[memoria_virtual|Administracion de memoria]]

3- [[driver_xv6|Gestor de E/S]]

= Enlaces de interés =
* '''Página oficial de QEMU'''
http://wiki.qemu.org/Main_Page
* '''Wiki de QEMU'''
https://en.wikibooks.org/wiki/QEMU
* '''Video Explicativo de la Instalación'''
https://vimeo.com/69135539
* '''Libro Usado en el MIT para explicar el funcionamiento del Xv6 (inglés)'''
https://pdos.csail.mit.edu/6.828/2012/xv6/book-rev7.pdf

Interrupciones y excepciones

2015-09-28T18:04:52Z

Migestgom: /* Tipos de interrupciones y excepciones */

==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, también conocida como excepción, 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 excepciones para notificar al sistema operativo que requiere de su intervención. Para lanzar una excepción, 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 excepciones, por medio de la instrucción '''int 0x80'''.

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.
[[Arranque del sistema|2.4 Arranque del sistema]]

Tipos de Sistemas Operativos

2015-09-28T16:34:23Z

Migestgom: /* Características que pueden presentar: */

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

=== '''Monoprogramables'''===
*En un determinado instante de tiempo, '''sólo hay un único proceso en ejecución que monopoliza todos los recursos''' del sistema.
*Principal ventaja: su sencillez.
*Dos subtipos:
**Ofrece intérprete de órdenes.
**Ofrece entrada a través de cinta/switches (SSOO históricos).
*Ejemplo: DOS.

=== '''Multiprogramables''' ===

*Permiten ejecutar '''múltiples procesos en un único procesador'''. Se tienen varios programas cargados simultáneamente en la memoria, así que el SO debe controlar los accesos y los espacios de la misma.
*Tienen mecanismos de protección del espacio de memoria (el SO impide que una aplicación acceda al espacio de memoria de otra).

====Características que pueden presentar:====

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

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

Clasificación no excluyente:

* Sistemas operativos de servidor
* Sistemas operativos de ordenador personal
* Sistemas operativos en tiempo real
* Sistemas operativos embarcados / integrados / "embebidos", ejemplos, dispositivos móviles o smartcard.
* Sistemas operativos web

2.1 [[Organización básica de un ordenador]]