Wiki de Sistemas Operativos - Contribuciones del usuario [es]

Evaluame mis contribuciones a la wiki

2013-01-19T11:33:55Z

Fraborcej:

A continuación, indica tu nombre y apellidos:

* Juan Carlos Roldán Salvador
* Daniel Ayala Hernández
* Daniel de los Reyes Leal
* Olga Minerva Moreno Martín IS-G1
* Vanessa Chipirrás Navalón
* Alejandro Sánchez Medina IS-G1
* Francisco Javier Borrego Cejudo IC-G2

Ejercicios de paginación y segmentación

2012-12-27T13:20:43Z

Fraborcej:

==Ejercicio 1==

El proceso ocupa: 1 KB de código, 4 KB de pila, 5KB ctes+globales

*Paginación pura (4KB de páginas) = 4 páginas -> 16 KB
El código requiere 1 página
La pila otra al completo
Las globales necesitan 2

*Segmentación pura = 3 segmentos, ocupan 10KB
El codigo ocupa un segmento de 1 KB
La pila uno de 4 KB
Para globales es otro de 5KB

*Combinado = 1 segmento de 4 páginas -> 16 KB

== Ejercicio 2==
''[Este ejercicio formó parte del tercer Control de Evaluación Continua del curso 2010/11, del 8 de junio de 2011]''

Suponga un sistema operativo con un administrador de memoria paginada cuyo tamaño de página es de 8KB. Se conoce que el sistema operativo funciona sobre un procesador cuyo tamaño de palabra es de 64 bits.

'''A)''' Calcule el tamaño máximo que puede llegar a alcanzar la tabla de página de un proceso, suponiendo que cada entrada de la tabla de páginas ocupa 128 bits.

'''B)''' Calcule cuántas páginas puede llegar a ocupar como máximo la tabla de páginas.

'''C)''' Dado un proceso en ejecución que requiere 7 Mbytes, calcule cuántas entradas de la tabla de páginas están siendo empleadas por dicho proceso en el sistema descrito anteriormente.

(''[[Solución de los ejercicios de paginación y segmentación#Ejercicio 2|Ver solución]]'')

PD: Podrían colocar todos los ejercicios del examen C3, y aquel que sepa las soluciones que las coloque si es tan amable.
-----------

¿Alguien recuerda los ejercicios que se pusieron en el tercer parcial? El ejercicio tipo test, y el de las 2 preguntas de pensar un poco.

== Ejercicio 3 ==
Tenemos 3 procesos (P1,P2 y P3): P1 ocupa 1KB, P2 ocupa 4 KB y P3 ocupa 2 KB.
El tamaño de las páginas es de 4 KB.
¿Cuál es el desperdicio interno?

*Del proceso 1 desperdiciamos: 4 KB - 1 KB = 3 KB
*Del proceso 2 no desperciamos nada.
*Del proceso 3 desperdiciamos: 4 KB - 2 KB = 2 KB
*Desperdicio intero total: 3 KB + 2 KB = 5 KB

== Ejercicio 4==
''[Este ejercicio formó parte del tercer Control de Evaluación Continua del curso 2012/13, del 21 de Diciembre de 2012 ]''

¿Que es el conjunto de trabajo de un proceso?

Conjunto de paginas que un proceso necesita en memoria principal para que no se produzcan fallos de pagina.
Lo ideal es que un proceso activo tenga todo su conjunto de trabajo en la memoria principal.

== Ejercicio 5==
''[Este ejercicio formó parte del tercer Control de Evaluación Continua del curso 2012/13, del 21 de Diciembre de 2012 ]''

Represente gráficamente la estructura del dispositivo de traducción de memoria de un sistema memoria combinado.

[http://sistemasoperativos.angelfire.com/html/imagenes/3.3.3_clip_image001.jpg Sistemas Combinados(Resultado)]

Ejercicios de paginación y segmentación

2012-12-27T13:20:30Z

Fraborcej:

Monitores

2012-11-28T22:26:21Z

Fraborcej: /* Fuentes */

Idea desarrollada en los años 70 Brinch-Hansen y Hoare <ref>http://java.sun.com/developer/Books/performance2/chap4.pdf</ref>que notaron los siguientes problemas con respecto al uso de los semáforos:

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

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

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

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

Permiten organizar procesos en espera mediante:

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

<source lang="java">

class recursoCompartido {

private int recursoCompartido;
private Semaforo s = 1;

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

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

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

== Ejemplo del funcionamiento de una clase monitor ==

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

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

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

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

Dichos hilos tienen el siguiente código:

* Lector (h1):

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

* Escritor (h2):

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

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

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

Asignación del recurso procesador

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

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

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

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

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

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

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

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

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

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

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

Monitores

2012-11-28T22:26:09Z

Fraborcej: /* Fuentes */

Monitores

2012-11-28T22:25:55Z

Fraborcej: /* Fuentes */

Monitores

2012-11-28T22:25:34Z

Fraborcej: /* Fuentes */ Cambiar link

Idea desarrollada en los años 70 Brinch-Hansen y Hoare <ref>http://java.sun.com/developer/Books/performance2/chap4.pdf</ref>que notaron los siguientes problemas con respecto al uso de los semáforos:

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

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

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

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

Permiten organizar procesos en espera mediante:

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

<source lang="java">

class recursoCompartido {

private int recursoCompartido;
private Semaforo s = 1;

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

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

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

== Ejemplo del funcionamiento de una clase monitor ==

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

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

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

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

Dichos hilos tienen el siguiente código:

* Lector (h1):

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

* Escritor (h2):

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

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

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

Asignación del recurso procesador

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

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

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

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

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

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

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

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

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

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

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

Monitores

2012-11-28T22:24:05Z

Fraborcej: /* Fuentes */

Idea desarrollada en los años 70 Brinch-Hansen y Hoare <ref>http://java.sun.com/developer/Books/performance2/chap4.pdf</ref>que notaron los siguientes problemas con respecto al uso de los semáforos:

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

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

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

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

Permiten organizar procesos en espera mediante:

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

<source lang="java">

class recursoCompartido {

private int recursoCompartido;
private Semaforo s = 1;

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

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

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

== Ejemplo del funcionamiento de una clase monitor ==

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

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

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

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

Dichos hilos tienen el siguiente código:

* Lector (h1):

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

* Escritor (h2):

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

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

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

Asignación del recurso procesador

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

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

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

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

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

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

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

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

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

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

== Fuentes ==
https://1984.lsi.us.es/wiki-ssoo/images/1/18/HPJPC_Christopher_and_Thiruvathukal_99_132
<references/>

Monitores

2012-11-28T22:23:39Z

Fraborcej: /* Fuentes */

Idea desarrollada en los años 70 Brinch-Hansen y Hoare <ref>http://java.sun.com/developer/Books/performance2/chap4.pdf</ref>que notaron los siguientes problemas con respecto al uso de los semáforos:

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

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

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

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

Permiten organizar procesos en espera mediante:

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

<source lang="java">

class recursoCompartido {

private int recursoCompartido;
private Semaforo s = 1;

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

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

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

== Ejemplo del funcionamiento de una clase monitor ==

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

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

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

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

Dichos hilos tienen el siguiente código:

* Lector (h1):

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

* Escritor (h2):

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

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

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

Asignación del recurso procesador

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

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

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

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

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

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

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

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

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

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

== Fuentes ==
https://1984.lsi.us.es/wiki-ssoo/images/1/18/HPJPC_Christopher_and_Thiruvathukal_99_132
</references>

Monitores

2012-11-28T22:23:17Z

Fraborcej: /* Fuentes */ Añadir link antiguo link estaba roto

Idea desarrollada en los años 70 Brinch-Hansen y Hoare <ref>http://java.sun.com/developer/Books/performance2/chap4.pdf</ref>que notaron los siguientes problemas con respecto al uso de los semáforos:

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

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

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

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

Permiten organizar procesos en espera mediante:

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

<source lang="java">

class recursoCompartido {

private int recursoCompartido;
private Semaforo s = 1;

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

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

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

== Ejemplo del funcionamiento de una clase monitor ==

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

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

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

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

Dichos hilos tienen el siguiente código:

* Lector (h1):

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

* Escritor (h2):

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

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

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

Asignación del recurso procesador

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

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

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

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

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

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

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

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

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

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

== Fuentes ==
https://1984.lsi.us.es/wiki-ssoo/images/1/18/HPJPC_Christopher_and_Thiruvathukal_99_132

Archivo:HPJPC Christopher and Thiruvathukal 99 132.pdf

2012-11-28T22:21:50Z

Fraborcej: Explicacion monitores

Explicacion monitores

Solución ejercicio 8

2012-11-22T11:24:11Z

Fraborcej:

X = El proceso pasa a estado bloqueado.
/ = El proceso pasa a estado preparado.
> = Fin de su ejecución

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

No hay sincronizacion, son semáforos diferentes operan cada uno sobre un proceso.

Solución ejercicio 9

2012-11-22T11:23:54Z

Fraborcej: Página creada con ' X = El proceso pasa a estado bloqueado. / = El proceso pasa a estado preparado. > = Fin de su ejecución | #1| #2| #3| | | #4| #1| #2| | | …'

X = El proceso pasa a estado bloqueado.
/ = El proceso pasa a estado preparado.
> = Fin de su ejecución

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

Solo hay un semáforo. No se mezclan las zonas criticas, el contador siempre se comparte.

Solución ejercicio 8

2012-11-22T11:18:21Z

Fraborcej: /ejercicio 8/ Editar solución

X = El proceso pasa a estado bloqueado.
/ = El proceso pasa a estado preparado.
> = Fin de su ejecución

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

No hay sincronizacion, son semáforos diferentes operan cada uno sobre un proceso.

Solución de los ejercicios de fundamentos

2012-11-11T19:05:07Z

Fraborcej: /*Añadir Ejercicio*/

== Ejercicio 1 ==

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

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

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

== Ejercicio 2 ==

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

== Ejercicio 2.6.2 ==

No es conveniente que se haga un Sistema operativo sin ninguna llamada a sistema ya que el sistema no se podría comunicar con el hardware y no valdría para nada. No es útil.--[[Usuario:fraborcej|fraborcej]] 19:49 11 nov 2012 (UTC)

== Ejercicio 3.3.2 ==

La mayor parte de los sistemas operativos son monolíticos, porque tienen un rendimiento mas alto, puesto que las peticiones entre los diferentes componentes se reducen a invocaciones de funciones. Mientras que el sistema operativo micronúcleo necesita de mensajería cada vez que hace una petición, la razón por la que tienen un rendimiento mas bajo. --[[Usuario:fraborcej|fraborcej]] 19:58 11 nov 2012 (UTC)

== Ejercicio 3.3.3 ==

El código de un sistema operativo que corre sobre una maquina virtual se ejecuto en modo no_privilegiado ya que la maquina virtual es un proceso por tanto se esta ejecutando en modo no_privilegiado. --[[Usuario:fraborcej|fraborcej]] 19:58 11 nov 2012 (UTC)

Ejercicios 3

2012-11-11T19:00:57Z

Fraborcej:

== Ejercicio 1 ==
''[Este ejercicio fue parte del Primer Control de Evaluación Contínua en el curso 2010/11, del 23 de marzo de 2011]''

Indique la diferencia fundamental de diseño entre un sistema operativo monolítico y otro micronúcleo.

(''[[Solución de los ejercicios de fundamentos#Ejercicio 1|Ver solución]]'')

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

Si los sistemas operativos micronúcleos se caracterizan por presumir de su fiabilidad, ¿Por que la mayor parte de los sistemas operativos de propósito general son híbridos (mas bien tendiendo a ser monolíticos)?

(''[[Solución de los ejercicios de fundamentos#Ejercicio 1|Ver solución]]'')

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

¿En que modo de la CPU se ejecuta el código de un sistema operativo que corre sobre una maquina virtual? Justifique brevemente su respuesta.

(''[[Solución de los ejercicios de fundamentos#Ejercicio 1|Ver solución]]'')

Solución de los ejercicios de fundamentos

2012-11-11T18:59:35Z

Fraborcej: /*Añadir Solución Ejercicio*/ Primer Examen evaluación continua 2012/2013

Ejercicios 3

2012-11-11T18:54:00Z

Fraborcej:

Solución de los ejercicios de fundamentos

2012-11-11T18:51:39Z

Fraborcej: /* Ejercicio 2.6.2 */

Solución de los ejercicios de fundamentos

2012-11-11T18:51:18Z

Fraborcej:

Solución de los ejercicios de fundamentos

2012-11-11T18:51:05Z

Fraborcej:

Solución de los ejercicios de fundamentos

2012-11-11T18:50:12Z

Fraborcej:

Solución de los ejercicios de fundamentos

2012-11-11T18:49:19Z

Fraborcej:

Ejercicios fundamentos Sistemas Operativos

2012-11-11T18:42:25Z

Fraborcej: /* Ejercicios */ Añadiendo Ejercicio Examen 09/11/2012

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

Enumere y detalle brevemente los cuatro componentes básicos de un Sistema Operativo, así como las interfaces que este ofrece para interactuar con él.

(''[[Solución de los ejercicios de fundamentos#Ejercicio 1|Ver solución]]'')

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

Los ingenieros de ACME Sistemas Operativos han decidido implementar un sistema operativo de propósito general que no ofrece ninguna llamada al sistema.Justifique brevemente la conveniencia,o no, de dicha decisión de diseño.

(''[[Solución de los ejercicios de fundamentos#Ejercicio 2|Ver solución]]'')

Ejercicios fundamentos Sistemas Operativos

2012-11-11T18:41:34Z

Fraborcej: /* Ejercicio 1 */

Ejercicios fundamentos Sistemas Operativos

2012-11-11T18:40:30Z

Fraborcej: /* Ejercicio 1 */

Sol-ejer3-planif-procesos

2012-11-03T20:55:19Z

Fraborcej: /* Ejercicio 3 */

= Ejercicio 2 =

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

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

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

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

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

Cálculo de índices:

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

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

Explicación:

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

= Dudas =

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Sol-ejer3-planif-procesos

2012-11-03T20:54:09Z

Fraborcej: /* Ejercicio 3 */ Correcion solución

= Ejercicio 3 =

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

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

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

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

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

Cálculo de índices:

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

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

Explicación:

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

= Dudas =

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Ejercicios planificación de procesos

2012-11-03T20:52:23Z

Fraborcej: /* Ejercicio 2 */ Correcion enunciado(añadir requisito).

= Ejercicio 1 =

Dada la siguiente configuración de procesos:

H0 t
PA 0 3
PB 1 5
PC 2 6

Teniendo en cuenta el siguiente comportamiento:

* El proceso A cada 1 unidad de tiempo de ejecución bloquea por operación de E/S
* El proceso B cada 3 unidades de tiempo de ejecución bloquea por operación de E/S

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

En caso de empate, considere que el orden de inserción a la cola de preparados es por orden de llegada (FIFO).

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

* Turno rotatorio estricto, suponiendo que el quantum es de 2 unidades de tiempo.
* Por prioridades, suponiendo que A < B < C.
* Turno rotatorio proporcional al número de procesos en estado preparado, suponiendo que el quantum es de 2 unidades de tiempo. Si hay dos o más procesos preparados el quantum pasa a ser de una unidad de tiempo.

[[sol-ejer2-planif-procesos|Ver solución ejercicio 1]]

= Ejercicio 2 =

En un planificador multinivel con realimentación se dispone de dos colas:

* La primera cola tiene procesos que reciben un ''quantum'' de 4 unidades de tiempo.
* La segunda cola tiene procesos que reciben un ''quantum'' de 2 unidades de tiempo. Los procesos en esta cola reciben dos oportunidades de ejecución. Por tanto, se itera dos veces sobre esta cola antes de pasar a la primera cola.

Los procesos que acaban de ser lanzados pasan inicialmente a la segunda cola. Si consumen completamente el ''quantum'' una vez, promocionan a la primera cola. Si dejan de consumir completamente el ''quantum'' una vez, descienden a la segunda.

Dada la siguiente configuración de procesos:

H0 t
Pa 0 4
Pb 1 4
Pc 2 12
Pd 3 12

Suponga que los procesos A y B bloquean por operación de E/S tras 1 unidad de ejecución. Los procesos C y D no bloquean. Los tiempos de bloqueo por E/S son de 1 unidad de tiempo. En toda decisión del planificador tenga en cuenta a los procesos que justo acaban de pasar a estado preparado tras un bloqueo.Represente gráficamente la evolución temporal de la asignación del procesador.

[[sol-ejer3-planif-procesos|Ver solución ejercicio 2]]

=Ejercicio 3 =
''[Este ejercicio formó parte del Primer Parcial de Evaluación Contínua del curso 2010/11 del 23 de marzo de 2011]''

Dada la siguiente configuracion de procesos:

{| border="2" cellpadding="4" cellspacing="0" style="margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;"
! width="50" style="background:#efefef;" | Proceso
! width="50" style="background:#efefef;" | H0
! width="50" style="background:#efefef;" | t
|-
| PA
| 0
| 3
|-
| PB
| 1
| 5
|-
| PC
| 2
| 6
|}

Teniendo en cuenta el siguiente comportamiento:

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

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

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

#Turno rotatorio con compensacion con quantum de 2 unidades de tiempo.

*En caso de que un proceso haya consumido el 50% de su quantum y en la cola de procesos preparados haya un unico proceso, insertelo delante de este.

*Si dos o mas procesos pasan de estado preparado a la vez, considere que el orden de insercion en la cola de preparados es el siguiente: 1ºA 2ºB 3ºC

*Recuerde que un proceso en estado bloqueado se inserta en la cola de preparados una vez que pasa el tiempo de bloqueo ( que en este ejercicio se trata de 2 unidades de tiempo)

*En toda decisión del planificador tenga en cuenta a los procesos que justo acaban de pasar a estado preparado tras un bloqueo.

''[[sol-ejer4-planif-procesos|Ver solución ejercicio 3]]''

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

Dado el código de los siguientes procesos:

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

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

De manera teórica, suponga que la ejecución de cada línea de código toma una unidad de tiempo. Considere que las llamadas '''write''' y '''printf''' son bloqueantes puesto que suponen accesos a dispositivos de E/S, siendo los tiempos de bloqueo de 3 unidades de tiempo. Suponga que ambos procesos se lanzan a la vez, pero el planificador da paso en primer lugar al proceso A.

Realice la traza temporal de ejecución de dichos procesos y los índices de penalización suponiendo planificación por turno rotatorio con compensación con ''quantum'' de 2 unidades de tiempo:

* En caso de que un proceso haya consumido el 50% de su quantum y en la cola de procesos preparados haya un único proceso, insértelo delante de éste.
* Si dos o más procesos pasan a estado preparado a la vez, considere que el orden de inserción de preparados en la cola es el siguiente: 1º-A, 2º-B.
* Recuerde que un proceso en estado bloqueado se inserta en la cola de preparados una vez que pasa el tiempo de bloqueo (que en este ejercicio se trata de 3 unidades de tiempo.
* En toda decisión del planificador tenga en cuenta los procesos que justo acaban de pasar a estado preparado tras un bloqueo.

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

Llamadas al sistema

2012-10-11T11:22:01Z

Fraborcej: /* Definición de llamada al sistema */ Llamada al sistema- open.

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

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

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

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

int main(void)
{
uint64_t segundos;

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

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

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

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

== Implementación de llamadas al sistema ==

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

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

mov eax, 1
mov ebx, 0
int 80h

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

La instrucción ''int'' forma parte del conjunto de instrucciones de procesadores x86. Esta instrucción emite una 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.

== El ''dispatcher'' ==

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

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

== El punto de entrada ==

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