Wiki de Sistemas Operativos - Contribuciones del usuario [es]

Página con listado de personas que han contribuido

2012-01-26T19:54:08Z

Albsolnog:

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

* luigarhor
* rafperper
* sergaralo
* josalgrod1
* felgaroje
* luimunlei
* [https://1984.lsi.us.es/wiki-ssoo/index.php/Usuario:Lorruimor Lorruimor]
* albsolnog

Solución ejercicio2 Mejor Ajuste Estático

2011-12-20T10:06:06Z

Albsolnog:

A
P1 <---|---|---|---> | | | | | | | | | | | | | | | |
B
P2 <---|---|---|---> | | | | | | | | | | | | | | | |
A
P3 < | | | <---|---|---|---> | | | | | | | | | | | |
C
P4 <---|---> | | | | | | | | | | | | | | | | | |
C
P5 < | |---> | | | | | | | | | | | | | | | | |
-----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

--[[Usuario:Albsolnog|Albsolnog]] 10:06 20 dic 2011 (UTC)
Duda: ¿en caso de empate como ocurre en este ejercicio entre P1,P2 y P3, que criterio se sigue para elegir primero P1, segundo P2 y tercero P3?.

Solución ejercicio 1

2011-12-13T11:36:50Z

Albsolnog:

X = El proceso pasa a estado bloqueado.
/ = El proceso pasa a estado preparado.

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

Observaciones:
* El proceso P2 bloquea al hacer down sobre el semáforo s2 cuyo contador vale 0.
* En el instante 15, el proceso P2 bloquea de nuevo pues hace down sobre el semáforo s2 cuyo contador vale 0.
* En los semáforos no se vuelve a comprobar la condición que hizo que el proceso bloqueara, a difencia de los cerrojos.

--[[Usuario:Pneira|Pneira]] 08:59 10 may 2011 (UTC)

'''Duda sobre el ejercicio:'''

He realizado varias veces la traza de los procesos y en el instante 15 el semáforo de s2 me sale 1,no sé si me estaré pasando algún detalle por alto.S2 empieza en 0,en el instante 7 P1 realiza un up en s2 (valor s2=1), y se realiza un down en el instante 15 por lo que volvería a valer 0, ¿qué estoy pasando por alto? :S --[[Usuario:Josedelfer|Josedelfer]] 11:00 13 dic 2011 (UTC)

--[[Usuario:Albsolnog|Albsolnog]] 11:36 13 dic 2011 (UTC) Fijate que para t=6 p2 estaba bloqueado y por tanto almacenado en la lista, justo aqui p1 realiza un up(S2) '''en el instante 6 no en el 7''' lo que implica que p2 pasa a estado preparado pero su contador no se toca (mira el codigo de up())

Sol-ejer3-planif-procesos

2011-11-14T08:43:25Z

Albsolnog: /* Nueva Duda: */

= 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

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

... continuación ...

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

Cálculo de índices:

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

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.--[[Usuario:Danjurfer|Danjurfer]] 12:36 11 nov 2011 (UTC)

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)

Sol-ejer2-1-otros-aspectos

2011-11-13T11:56:48Z

Albsolnog: /* SJF Apropiativo con multiprocesamiento */

== SJF Apropiativo con multiprocesamiento ==

Para este caso disponemos de 2 Procesadores, y supondremos que el planificador se ejecuta en uno de ellos
____|_PA_|_PB_|_PC_| PA bloquea cada 1 u.t.
Datos del _H0_|_0__|_1__|_2__| PB bloquea cada 3 u.t.
problema _t__|_3__|_5__|_6__| tiempo de bloqueo=2 u.t.

< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
X = se ejecuta el código del planificador
# = el proceso se bloquea
+++ = procesador 1
--- = procesador 2

| | | | | | | | | | | | |
Pa <+++# | <+++# | |+++> | | | | |
Pb | <+++|+++|---# | |---|+++> | | |
Pc | | <---| |+++|+++| |---|---|---> | |
Planificador X X X X X | X X | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___> t
0 1 2 3 4 5 6 7 8 9 10 11 12

_____|_PA_|_PB_|_PC_|
Cálculos __t__|_3__|_5__|_6__|
de tiempos __T__|_7__|_7__|_8__|
_T/t_|_2.3|_1.4|_1.3|
|
|_> Indice de penalización

'''OBSERVACIONES:'''

*En esta solución suponemos que en en el procesador 1 se ejecuta el proceso más corto preparado y en el procesador 2 se ejecuta el 2º más corto preparado.

*Por lo anterior indicado, la solución podría variar entre la unidad de tiempo 7 y la 10, pero como no nos han dado expresamente un criterio para asignar a los procesadores los procesos, no tiene importancia.

**Esta solucion propuesta tiene fallo en t=8,ya que el procesador 2 esta ejecutando el proceso c mientras que el procesador 1 no tiene ningun proceso asignado,,,en el enunciado dice que este procesador 2 solo ejecutara si procesador 1 esta ejecutando y no es el caso.

*'''Importante''': Este ejercicio (de momento) no ha sido corregido por Pablo Neira, es por ello que si alguien tiene una duda sobre él debería indicarlo para discutirlo hasta que dicho profesor lo revise.

'''OTRA SOLUCION'''
* Comienzo con la idea de que el planificador es un componente del sistema operativo y no de un procesador concreto, por lo que decidirá en cada momento que proceso será asignado al recurso procesador, para este caso tenemos 2 procesadores y como dice el enunciado solo se asignaran al segundo si el primero está ocupado,he considerado para este caso asignar el proceso A en t=3 al procesador 2 aunque es prioritario sobre B al que tendría que retirarle el 1, para de esta manera aplicar el principio de localizacion espacio temporal y ahorrar costes en posibles fallos de migracion de la memoria cache, '''solo cambio de procesador una vez, para el proceso A''' --[[Usuario:Albsolnog|Albsolnog]] 11:56 13 nov 2011 (UTC)

X Ejecucion del planificador
F Fin de proceso
--- Procesador 1
+++ Procesador 2
* Estado Bloqueado
& Estado Preparado
Fin Finalizacion del proceso

| | | | | | | | | | | | |
Pa <---* | &+++* | &+++Fin | | | | |
Pb | <---|---|---* | &---|---Fin | | | |
Pc | | <+++| |+++|+++| |+++|+++|+++Fin | |
Planificador X X X X X | X X | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___> t
0 1 2 3 4 5 6 7 8 9 10 11 12

Sol-ejer3-planif-procesos

2011-11-13T11:55:21Z

Albsolnog: /* Nueva Duda: */

= 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

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

... continuación ...

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

Cálculo de índices:

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

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.--[[Usuario:Danjurfer|Danjurfer]] 12:36 11 nov 2011 (UTC)

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)

Sol-ejer3-planif-procesos

2011-11-13T11:53:44Z

Albsolnog: /* Nueva Duda: */

= 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

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

... continuación ...

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

Cálculo de índices:

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

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.--[[Usuario:Danjurfer|Danjurfer]] 12:36 11 nov 2011 (UTC)

Fijate que en el instante de tiempo t=8 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)

Sol-ejer6-planif-procesos

2011-11-13T11:06:59Z

Albsolnog: /* Apartado c */

= Apartado a =

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

< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
& = el proceso bloquea debido a una llamada bloqueante
# = el proceso bloquea debido a que ha consumido su cuanto
X = se ejecuta el código del planificador
p = el proceso pasa a estado preparado

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

-Respuesta: debido a que el quantum tiene un tamaño muy pequeño el planificador de tareas se ejecuta continuamente (tiempo del sistema alto) con lo que el rendimiento se verá afectado.

DUDA: En t=5 ¿por qué se inicia PC en vez de PD? Si entra PD en t=5 se debería ejecutar porque en RR estricto los procesos recién lanzados deben ejecutarse, similar a lo de orden de llegada. He pensado que puede ser por la prioridad pero esque aquí en la tabla no viene las prioridades, solo H0 y t. --Luisa Mª.

- En t=4 se han ejecutado Pa,Pb y Pc, entonces le tocaría el turno a Pd pero como en ese momento no está preparado se le pasa el turno a Pa otra vez, después de ejecutarse este se le pasa el turno a Pb pero como ya ha terminado de ejecutarse se salta al proceso siguiente: Pc. ¡Aunque también es posible que me haya equivocado! --[[Usuario:jesgonbel|jesgonbel]].

- Creo que como dice Luisa se debería ejecutar PD, porque los recien llegados tienen prioridad frente a los que ya se han iniciado.--[[Usuario:Josmorsot|Josmorsot]] 12:39 11 nov 2011 (UTC)

- Mirad el enunciado, el proceso C tiene una prioridad superior a D. Juan Ignacio.

= Apartado b =

En ambos casos la solución es la misma.

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

< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
& = el proceso bloquea debido a una llamada bloqueante
# = el proceso bloquea debido a que ha consumido su cuanto
X = se ejecuta el código del planificador
p = el proceso pasa a estado preparado

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

DUDA: No entiendo que eso de que bloquea cuando su quantum es 1 si en uno de SJF no hay quantum además dudo que ambas soluciones sean iguales ya que en uno apropiativo se le puede retirar el proceso, en cuanto haya uno mas corto en estado preparado, que alguien me corrija si me equivoco, gracias.

= Apartado c =

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

< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
& = el proceso bloquea debido a una llamada bloqueante
# = el proceso bloquea debido a que el planificador le retira el procesador
X = se ejecuta el código del planificador
p = el proceso pasa a estado preparado

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

Indices de penalizacion: PA=9 PB=1 PC=7/4 PD=9/6

Duda: ¿porqué en el instante t=8 no se le asigna el recurso procesador al proceso A, siendo su penalizacion mayor que C?

Sol-ejer2-1-otros-aspectos

2011-11-12T06:58:28Z

Albsolnog: /* SJF Apropiativo con multiprocesamiento */

== SJF Apropiativo con multiprocesamiento ==

Para este caso disponemos de 2 Procesadores, y supondremos que el planificador se ejecuta en uno de ellos
____|_PA_|_PB_|_PC_| PA bloquea cada 1 u.t.
Datos del _H0_|_0__|_1__|_2__| PB bloquea cada 3 u.t.
problema _t__|_3__|_5__|_6__| tiempo de bloqueo=2 u.t.

< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
X = se ejecuta el código del planificador
# = el proceso se bloquea
+++ = procesador 1
--- = procesador 2

| | | | | | | | | | | | |
Pa <+++# | <+++# | |+++> | | | | |
Pb | <+++|+++|---# | |---|+++> | | |
Pc | | <---| |+++|+++| |---|---|---> | |
Planificador X X X X X | X X | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___> t
0 1 2 3 4 5 6 7 8 9 10 11 12

_____|_PA_|_PB_|_PC_|
Cálculos __t__|_3__|_5__|_6__|
de tiempos __T__|_7__|_7__|_8__|
_T/t_|_2.3|_1.4|_1.3|
|
|_> Indice de penalización

'''OBSERVACIONES:'''

*En esta solución suponemos que en en el procesador 1 se ejecuta el proceso más corto preparado y en el procesador 2 se ejecuta el 2º más corto preparado.

*Por lo anterior indicado, la solución podría variar entre la unidad de tiempo 7 y la 10, pero como no nos han dado expresamente un criterio para asignar a los procesadores los procesos, no tiene importancia.

*'''Importante''': Este ejercicio (de momento) no ha sido corregido por Pablo Neira, es por ello que si alguien tiene una duda sobre él debería indicarlo para discutirlo hasta que dicho profesor lo revise.

'''OTRA SOLUCION'''
* Comienzo con la idea de que el planificador es un componente del sistema operativo y no de un procesador concreto, por lo que decidirá en cada momento que proceso será asignado al recurso procesador, para este caso tenemos 2 procesadores y como dice el enunciado solo se asignaran al segundo si el primero está ocupado,he considerado para este caso asignar el proceso A en t=3 al procesador 2 aunque es prioritario sobre B al que tendría que retirarle el 1, para de esta manera aplicar el principio de localizacion espacio temporal y ahorrar costes en posibles fallos de migracion de la memoria cache, '''solo cambio de procesador una vez, para el proceso A'''

X Ejecucion del planificador
F Fin de proceso
--- Procesador 1
+++ Procesador 2
* Estado Bloqueado
& Estado Preparado
Fin Finalizacion del proceso

| | | | | | | | | | | | |
Pa <---* | &+++* | &+++Fin | | | | |
Pb | <---|---|---* | &---|---Fin | | | |
Pc | | <+++| |+++|+++| |+++|+++|+++Fin | |
Planificador X X X X X | X X | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___> t
0 1 2 3 4 5 6 7 8 9 10 11 12

Sol-ejer2-1-otros-aspectos

2011-11-12T06:57:37Z

Albsolnog: /* SJF Apropiativo con multiprocesamiento */

== SJF Apropiativo con multiprocesamiento ==

Para este caso disponemos de 2 Procesadores, y supondremos que el planificador se ejecuta en uno de ellos
____|_PA_|_PB_|_PC_| PA bloquea cada 1 u.t.
Datos del _H0_|_0__|_1__|_2__| PB bloquea cada 3 u.t.
problema _t__|_3__|_5__|_6__| tiempo de bloqueo=2 u.t.

< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
X = se ejecuta el código del planificador
# = el proceso se bloquea
+++ = procesador 1
--- = procesador 2

| | | | | | | | | | | | |
Pa <+++# | <+++# | |+++> | | | | |
Pb | <+++|+++|---# | |---|+++> | | |
Pc | | <---| |+++|+++| |---|---|---> | |
Planificador X X X X X | X X | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___> t
0 1 2 3 4 5 6 7 8 9 10 11 12

_____|_PA_|_PB_|_PC_|
Cálculos __t__|_3__|_5__|_6__|
de tiempos __T__|_7__|_7__|_8__|
_T/t_|_2.3|_1.4|_1.3|
|
|_> Indice de penalización

'''OBSERVACIONES:'''

*En esta solución suponemos que en en el procesador 1 se ejecuta el proceso más corto preparado y en el procesador 2 se ejecuta el 2º más corto preparado.

*Por lo anterior indicado, la solución podría variar entre la unidad de tiempo 7 y la 10, pero como no nos han dado expresamente un criterio para asignar a los procesadores los procesos, no tiene importancia.

*'''Importante''': Este ejercicio (de momento) no ha sido corregido por Pablo Neira, es por ello que si alguien tiene una duda sobre él debería indicarlo para discutirlo hasta que dicho profesor lo revise.

'''OTRA SOLUCION'''
* Comienzo con la idea de que el planificador es un componente del sistema operativo y no de un procesador concreto, por lo que decidirá en cada momento que proceso será asignado al recurso procesador, para este caso tenemos 2 procesadores y como dice el enunciado solo se asignaran al segundo si el primero está ocupado,he considerado para este caso asignar el proceso A en t=3 al procesador 2 aunque es prioritario sobre B al que tendría que retirarle el 1, para de esta manera aplicar el principio de localizacion espacio temporal y ahorrar costes en posibles fallos de migracion de la memoria cache, '''solo cambio de procesador una vez, para los procesos A'''

X Ejecucion del planificador
F Fin de proceso
--- Procesador 1
+++ Procesador 2
* Estado Bloqueado
& Estado Preparado
Fin Finalizacion del proceso

| | | | | | | | | | | | |
Pa <---* | &+++* | &+++Fin | | | | |
Pb | <---|---|---* | &---|---Fin | | | |
Pc | | <+++| |+++|+++| |+++|+++|+++Fin | |
Planificador X X X X X | X X | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___> t
0 1 2 3 4 5 6 7 8 9 10 11 12

Sol-ejer2-1-otros-aspectos

2011-11-12T06:55:52Z

Albsolnog: /* SJF Apropiativo con multiprocesamiento */

== SJF Apropiativo con multiprocesamiento ==

Para este caso disponemos de 2 Procesadores, y supondremos que el planificador se ejecuta en uno de ellos
____|_PA_|_PB_|_PC_| PA bloquea cada 1 u.t.
Datos del _H0_|_0__|_1__|_2__| PB bloquea cada 3 u.t.
problema _t__|_3__|_5__|_6__| tiempo de bloqueo=2 u.t.

< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
X = se ejecuta el código del planificador
# = el proceso se bloquea
+++ = procesador 1
--- = procesador 2

| | | | | | | | | | | | |
Pa <+++# | <+++# | |+++> | | | | |
Pb | <+++|+++|---# | |---|+++> | | |
Pc | | <---| |+++|+++| |---|---|---> | |
Planificador X X X X X | X X | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___> t
0 1 2 3 4 5 6 7 8 9 10 11 12

_____|_PA_|_PB_|_PC_|
Cálculos __t__|_3__|_5__|_6__|
de tiempos __T__|_7__|_7__|_8__|
_T/t_|_2.3|_1.4|_1.3|
|
|_> Indice de penalización

'''OBSERVACIONES:'''

*En esta solución suponemos que en en el procesador 1 se ejecuta el proceso más corto preparado y en el procesador 2 se ejecuta el 2º más corto preparado.

*Por lo anterior indicado, la solución podría variar entre la unidad de tiempo 7 y la 10, pero como no nos han dado expresamente un criterio para asignar a los procesadores los procesos, no tiene importancia.

*'''Importante''': Este ejercicio (de momento) no ha sido corregido por Pablo Neira, es por ello que si alguien tiene una duda sobre él debería indicarlo para discutirlo hasta que dicho profesor lo revise.

'''OTRA SOLUCION'''
* Comienzo con la idea de que el planificador es un componente del sistema operativo y no de un procesador concreto, por lo que decidirá en cada momento que proceso será asignado al recurso procesador, para este caso tenemos 2 procesadores y como dice el enunciado solo se asignaran al segundo si el primero está ocupado,he considerado para este caso asignar el proceso A en t=3 al procesador 2 aunque es prioritario sobre B al que tendría que retirarle el 1, para de esta manera aplicar el principio de localizacion espacio temporal y ahorrar costes en posibles fallos de migracion de la memoria cache, '''solo cambio de procesador una vez, para los procesos A y C'''

X Ejecucion del planificador
F Fin de proceso
--- Procesador 1
+++ Procesador 2
* Estado Bloqueado
& Estado Preparado
Fin Finalizacion del proceso

| | | | | | | | | | | | |
Pa <---* | &+++* | &+++Fin | | | | |
Pb | <---|---|---* | &---|---Fin | | | |
Pc | | <+++| |+++|+++| |+++|+++|+++Fin | |
Planificador X X X X X | X X | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___> t
0 1 2 3 4 5 6 7 8 9 10 11 12

Sol-ejer2-1-otros-aspectos

2011-11-12T06:54:19Z

Albsolnog: /* SJF Apropiativo con multiprocesamiento */

== SJF Apropiativo con multiprocesamiento ==

Para este caso disponemos de 2 Procesadores, y supondremos que el planificador se ejecuta en uno de ellos
____|_PA_|_PB_|_PC_| PA bloquea cada 1 u.t.
Datos del _H0_|_0__|_1__|_2__| PB bloquea cada 3 u.t.
problema _t__|_3__|_5__|_6__| tiempo de bloqueo=2 u.t.

< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
X = se ejecuta el código del planificador
# = el proceso se bloquea
+++ = procesador 1
--- = procesador 2

| | | | | | | | | | | | |
Pa <+++# | <+++# | |+++> | | | | |
Pb | <+++|+++|---# | |---|+++> | | |
Pc | | <---| |+++|+++| |---|---|---> | |
Planificador X X X X X | X X | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___> t
0 1 2 3 4 5 6 7 8 9 10 11 12

_____|_PA_|_PB_|_PC_|
Cálculos __t__|_3__|_5__|_6__|
de tiempos __T__|_7__|_7__|_8__|
_T/t_|_2.3|_1.4|_1.3|
|
|_> Indice de penalización

'''OBSERVACIONES:'''

*En esta solución suponemos que en en el procesador 1 se ejecuta el proceso más corto preparado y en el procesador 2 se ejecuta el 2º más corto preparado.

*Por lo anterior indicado, la solución podría variar entre la unidad de tiempo 7 y la 10, pero como no nos han dado expresamente un criterio para asignar a los procesadores los procesos, no tiene importancia.

*'''Importante''': Este ejercicio (de momento) no ha sido corregido por Pablo Neira, es por ello que si alguien tiene una duda sobre él debería indicarlo para discutirlo hasta que dicho profesor lo revise.

*OTRA SOLUCION
* Comienzo con la idea de que el planificador es un componente del sistema operativo y no de un procesador concreto, por lo que decidirá en cada momento que proceso será asignado al recurso procesador, para este caso tenemos 2 procesadores y como dice el enunciado solo se asignaran al segundo si el primero está ocupado,he considerado para este caso asignar el proceso A en t=3 al procesador 2 aunque es prioritario sobre B al que tendría que retirarle el 1, para de esta manera aplicar el principio de localizacion espacio temporal y ahorrar costes en posibles fallos de migracion de la memoria cache, '''solo cambio de procesador una vez, para los procesos B y C'''

X Ejecucion del planificador
F Fin de proceso
--- Procesador 1
+++ Procesador 2
* Estado Bloqueado
& Estado Preparado
Fin Finalizacion del proceso

| | | | | | | | | | | | |
Pa <---* | &+++* | &+++Fin | | | | |
Pb | <---|---|---* | &---|---Fin | | | |
Pc | | <+++| |+++|+++| |+++|+++|+++Fin | |
Planificador X X X X X | X X | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___> t
0 1 2 3 4 5 6 7 8 9 10 11 12

Sol-ejer2-planif-procesos

2011-11-11T10:36:38Z

Albsolnog: /* Por prioridades */

= Turno rotatorio estricto =

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

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

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

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

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

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

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

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

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

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

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

= Por prioridades =

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

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

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

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

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

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

= Turno rotatorio proporcional al número de procesos =

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

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

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

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

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

Semáforos

2011-11-11T08:13:33Z

Albsolnog: /* Semáforos */

= Planificador de procesos: Diagrama de estados simplicado =

Para comprender apropiadamente cómo funcionan los semáforos vamos a recordar el diagrama de estados simplificado que emplea el planificador de procesos del sistema operativo.

|---------------|
pendiente | | recibido
evento ---------> | bloqueado |----------- evento
externo | | | | externo
| |---------------| |
| |
| planificador \/
|--------------| retira CPU |---------------|
| | -------------------> | |
| activo | | preparado |
| | <------------------- | |
|--------------| |---------------|
planificador
asigna CPU

La vida de un proceso pasa por tres estados:

* Activo: el proceso está empleando la CPU, por tanto, está ejecutándose. Hay tantos procesos activos como recurso de procesamiento disponible. Por tanto, si el sistema dispone de un único procesador, únicamente puede haber un proceso activo a la vez.
* Preparado: el proceso no está ejecutándose pero es candidato a pasar a estado activo. Es el planificador el que, en base a un criterio de planificación, decide qué proceso selecciona de la lista de procesos preparados para pasar a estado activo.
* Bloqueado: el proceso está pendiente de un evento externo, tales como la espera de finalización de un proceso hijo, una señal, una operación sobre un semáforo o una operación de lectura/escritura.

La transición de activo a preparado y viceversa depende de decisiones tomadas por el planificador del sistema operativo (que emplea algún criterio visto en clases teóricas, tales como el turno rotatorio), el programador no puede interferir en estas decisiones. Mientras que la transición de activo a bloqueado, y de bloqueado a preparado pueden ser controladas por el programador mediante llamadas al sistema.

= Semáforos =

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

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

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

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

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

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

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

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

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

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

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

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

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

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

=== Tipos de semáforos ===

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

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

=== Ventajas e inconvenientes ===

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

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

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

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

Conceptos básicos

2011-11-06T10:32:35Z

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

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

== Programa ==

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

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

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

== Proceso ==

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

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

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

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

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

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

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

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

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

=== Procesos padre e hijo ===

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

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

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

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

== Llamadas a sistema ==

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

== Usuario ==

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

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

== Fichero ==

* Estructura de datos que almacena información.

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

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

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

Conceptos básicos

2011-11-06T10:32:01Z

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

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

== Programa ==

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

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

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

== Proceso ==

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

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

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

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

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

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

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

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

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

=== Procesos padre e hijo ===

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

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

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

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

== Llamadas a sistema ==

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

== Usuario ==

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

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

== Fichero ==

* Estructura de datos que almacena información.

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

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

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

Conceptos básicos

2011-11-06T10:31:26Z

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

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

== Programa ==

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

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

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

== Proceso ==

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

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

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

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

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

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

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

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

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

=== Procesos padre e hijo ===

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

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

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

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

== Llamadas a sistema ==

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

== Usuario ==

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

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

== Fichero ==

* Estructura de datos que almacena información.

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

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

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

Tipos de Sistemas Operativos

2011-11-06T10:17:12Z

Albsolnog: /* 1.3.2. Según cómo se presta el servicio */

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

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

*b. 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).
**b.1. 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 "Multitarea".
***Multiusuario: admite múltiples usuarios trabajando simultáneamente.
***Multiacceso: el sistema ofrece varios terminales (mecanismos) para acceso concurrente a él.
***Multiprocesamiento: soporta más de un procesador y hace uso de todos ellos.
***Tiempo real: intenta garantizar que determinadas tareas se ejecuten en un plazo de tiempo determinado. Atendiendo al nivel de exigencia, se subdividirían en dos: soft (suave) o '''flexible''' y hard(duro) o '''estricto'''.
***Distribuido: permite la ejecución de múltiples procesos en diferentes máquinas comunicadas por un enlace de red. El primer SO es soportar esta característica fue [http://es.wikipedia.org/wiki/Plan_9_from_Bell_Labs Plan 9] de ''Bell Labs''.

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

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

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

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

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

Tipos de Sistemas Operativos

2011-11-06T10:14:35Z

Albsolnog: /* 1.3.2. Según cómo se presta el servicio */

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

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

*b. 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).
**b.1. 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 "Multitarea".
***Multiusuario: admite múltiples usuarios trabajando simultáneamente.
***Multiacceso: el sistema ofrece varios terminales (mecanismos) para acceso concurrente a él.
***Multiprocesamiento: soporta más de un procesador y hace uso de todos ellos.
***Tiempo real: intenta garantizar que determinadas tareas se ejecuten en un plazo de tiempo determinado. Atendiendo al nivel de exigencia, se subdividirían en dos: soft (suave) o '''flexible''' y hard(duro) o '''estricto'''.
***Distribuido: permite la ejecución de múltiples procesos en diferentes máquinas comunicadas por un enlace de red. El primer SO es soportar esta característica fue [http://es.wikipedia.org/wiki/Plan_9_from_Bell_Labs Plan 9] de ''Bell Labs''.

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

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

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

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

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