Wiki de Sistemas Operativos - Contribuciones del usuario [es]

Mejoras de tiempos de desplazamiento

2011-06-06T15:58:31Z

Jorcalmar:

;1. FCFS (por orden de llegada): Las peticiones se atienden en el mismo orden en que se reciben.

;2. SSTF (por menor tiempo de búsqueda): Ordeno todo y cojo el lote.

;3. SCAN (criterio del ascensor):

;4. NSCAN: Dentro de cada lote de la lista de accesos, escogemos aquellos sectores que nos permita ascender y descender en la tabla, dando prioridad a los sectores que se encuentren en la parte central de la pista.

|
| /\ | /\
| / \ | / \
| / \ | / \
___|/______\|/______\__
|
Nota: La gráfica resultante no tiene por qué ser simétrica, dependerá de los sectores a los que accedamos.
Nota2: El número de sectores integrantes de cada lote será el indicado por la N, ejemplo: 3-SCAN, 4-SCAN, etc.

;5. C-SCAN (Circular-Scan): Da preferencia al ascenso o descenso, y se mantiene. Así se elimina el trato favorable a las partes centrales.

Mejoras de tiempos de desplazamiento

2011-06-06T15:58:20Z

Jorcalmar:

;1. FCFS (por orden de llegada): Las peticiones se atienden en el mismo orden en que se reciben.

;2. SSTF (por menor tiempo de búsqueda): Ordeno todo y cojo el lote.

;3. SCAN (criterio del ascensor): D

;4. NSCAN: entro de cada lote de la lista de accesos, escogemos aquellos sectores que nos permita ascender y descender en la tabla, dando prioridad a los sectores que se encuentren en la parte central de la pista.

|
| /\ | /\
| / \ | / \
| / \ | / \
___|/______\|/______\__
|
Nota: La gráfica resultante no tiene por qué ser simétrica, dependerá de los sectores a los que accedamos.
Nota2: El número de sectores integrantes de cada lote será el indicado por la N, ejemplo: 3-SCAN, 4-SCAN, etc.

;5. C-SCAN (Circular-Scan): Da preferencia al ascenso o descenso, y se mantiene. Así se elimina el trato favorable a las partes centrales.

Mejoras de tiempos de desplazamiento

2011-06-06T15:54:06Z

Jorcalmar:

;1. FCFS (por orden de llegada): Las peticiones se atienden en el mismo orden en que se reciben.

;2. SSTF (por menor tiempo de búsqueda): Ordeno todo y cojo el lote.

;3. SCAN (criterio del ascensor): Dentro de cada lote de la lista de accesos, escogemos aquellos sectores que nos permita ascender y descender en la tabla, dando prioridad a los sectores que se encuentren en la parte central de la pista.

|
| /\ | /\
| / \ | / \
| / \ | / \
___|/______\|/______\__
|
Nota: La gráfica resultante no tiene por qué ser simétrica, dependerá de los sectores a los que accedamos.

;4. NSCAN

;5. C-SCAN (Circular-Scan): Da preferencia al ascenso o descenso, y se mantiene. Así se elimina el trato favorable a las partes centrales.

Mejoras de tiempos de desplazamiento

2011-06-06T15:53:34Z

Jorcalmar:

;1. FCFS (por orden de llegada): Las peticiones se atienden en el mismo orden en que se reciben.

;2. SSTF (por menor tiempo de búsqueda): Ordeno todo y cojo el lote.

;3. SCAN (criterio del ascensor): Dentro del lote de nuestro sector, escogemos aquellos sectores que nos permita ascender y descender en la tabla, dando prioridad a los sectores que se encuentren en la parte central de la pista.

|
| /\ | /\
| / \ | / \
| / \ | / \
___|/______\|/______\__
|
Nota: La gráfica resultante no tiene por qué ser simétrica, dependerá de los sectores a los que accedamos.

;4. NSCAN

;5. C-SCAN (Circular-Scan): Da preferencia al ascenso o descenso, y se mantiene. Así se elimina el trato favorable a las partes centrales.

Sol 9.2

2011-06-04T23:50:30Z

Jorcalmar:

La lista de paginas a la que se acceden son las siguientes : '''2--2--3--1--1--3--4--5--1--1--2--3--4'''

_________________accesos a página____________________
|_2_|_2_|_3_|_1_||_1_|_3_|_4_|_5_||_1_|_1_|_2_|_3_|_4_| ||=desplazamiento a la derecha
=========================================================
1 | 2 | = | = | = || 2 | = | = | 5 || 5 | = | = | = | 4 |
|100| = | = | = ||010| = | = |100||010| = | = | = |100|
m---|---|---|---|---||---|---|---|---||---|---|---|---|---|
a 2 | | | 3 | = || 3 | 3 | = | = || 3 | = | = | 3 | = |
r | | |100| = ||010|110| = | = ||011| = | = |111| = |
c---|---|---|---|---||---|---|---|---||---|---|---|---|---|
o 3 | | | | 1 || 1 | = | = | = || 1 | = | = | = | = |
s | | | |100||100| = | = | = ||111| = | = | = | = |
---|---|---|---|---||---|---|---|---||---|---|---|---|---|
4 | | | | || | | 4 | = || 4 | = | 2 | = | = |
| | | | || | |100| = ||010| = |100| = | = |
------------------------------------------------------------> t
x x x x x x

DUDA! No debería tener el marco 3 como contenido 1 / 110? coincide un desplazamiento y un acceso a la dereecha, como ocurre con el contenido del marco 2 cuando se accede al 3.

Sol 3

2011-06-02T16:52:34Z

Jorcalmar:

Solución:
6/13 = 0'4615
--[[Usuario:Jorcalmar|Jorcalmar]] 16:52 2 jun 2011 (UTC)

Sol 3

2011-06-02T16:52:11Z

Jorcalmar: Página creada con 'Solución: <math>6/13 = 0'46</math> --~~~~'

Solución:
<math>6/13 = 0'46</math>
--[[Usuario:Jorcalmar|Jorcalmar]] 16:52 2 jun 2011 (UTC)

Criterios de reemplazo

2011-06-02T16:49:43Z

Jorcalmar:

= '''Criterios de reemplazo''' =

La evaluación se hace en base a la ''tasa de fallos de página'', que es el número de fallos de página entre el número de accesos totales a página, con lo que su valor oscila en el rango [0,1].
El fallo de página se da cuando se accede a una posición de memoria que esta descargada en disco.

nº fallos pág.
tasa fallos pág = -----------------
nº accesos pág.

También hay que tener en cuenta el contexto, si estamos en arranque en frío o en caliente, así como el cumplimiento del principio de localidad espacial y temporal.

* Arranque en frío : se dan muchos fallos de página al principio, ya que los procesos se acaban de lanzar y ninguno esta cargado en memoria principal.
* Arranque en caliente : se suponen ya cargadas las páginas de los procesos en memoria principal.

==Criterios==
Ejemplo: Secuencia de acceso a página : 2,2,3,1,1,3,4,5,1,1,2,3,4
Suponiendo arranque en frío
___1____ 2_____3_____4___
memoria principal | | | | |
de 4 marcos |_____|_____|_____|_____|

'''1º) Criterio de página óptima :''' este es un criterio teórico que viene a establecer la cota inferior de la ''tasa de fallos de página''. Consiste en escoger la página que mayor tiempo va a tardar en utilizarse. Este es el mejor caso, pero se necesita conocimiento de futuro, de ahí que sea un criterio teórico.

[[sol_1|Solución]]

'''2º) Criterio de página pésima :''' este también es teórico y viene a establecer la cota superior de la ''tasa de fallos de página'', para ver lo peor que podría comportarse un criterio. Consiste en seleccionar la página que menor tiempo tardará en usarse.

[[sol_2|Solución]]

'''3º) Criterio MRU''' ('''M'''ost '''R'''ecently '''U'''sed) ''':''' página más recientemente usada. Se selecciona la última página a la que se ha accedido. Podría implementarse con una LIFO por orden de acceso.

[[sol_3|Solución]]

'''4º) Criterio de selección estocástica (aleatoria):''' Consiste en seleccionar una página al azar.

'''5º) Criterio por orden de carga FIFO''' : Se selecciona la página que más tiempo lleva cargada en memoria principal. Se implementa con una FIFO por orden de carga, es decir, a medida que se cargan en memoria principal las páginas son añadidas a la cola.

Un problema es que suele suceder que las páginas más usadas tienden a estar mucho tiempo en memoria principal y este criterio va contra eso.

[[sol_5|Solución]]

'''6º) Criterio NRU''' ('''N'''ot '''R'''ecently '''U'''sed) ''':''' Ofrece dos bits para cada página:
* bit R : Se pone a 1 si la página ha sido usada (tanto para lectura como para escritura).
* bit M : Se pone a 1 si la página es modificada (escritura).
Para seleccionar la página victima buscamos que cumpla uno de los siguientes criterios de bits si no hay ninguno se utiliza el siguiente:

1º- R=0, M=0 .

2º- R=0, M=1 .

3º- R=1, M=0 .

4º- R=1, M=1 .

Claramente deben realizarse periodos de puesta a 0, que no tienen porque ser simultáneamente en R y M.

[[sol_6|Solución]]

'''7º) Criterio de 2ª oportunidad :''' Se trata de la unión del dos criterios, FIFO más NRU sin el bit M. Tampoco se pone R a 0 periódicamente. Consiste en recorrer la cola hasta encontrar una página con R a 0 y los procesos que vaya encontrando con R a 1 se les pone R a 0 y se les da una segunda oportunidad poniéndolos al final de la cola.

[[sol_7|Solución]]

'''8º) Criterio LRU''' ('''L'''east '''R'''ecently '''U'''sed) ''':''' Criterio en contraposición al MRU. En MRU elegíamos aquella página que hubiéramos utilizado más recientemente (la primera de la pila de acceso) mientras que en LRU elegimos como página víctima lo contrario: La última página de la pila.

Otro ejemplo

2011-05-31T17:43:25Z

Jorcalmar:

Ej: tenemos los siguientes procesos: m(P1)=6KB,m(P2)=1KB,m(P3)=3KB,m(P4)=31KB,m(P5)=30KB,m(P6)=2KB,m(P7)=4KB,m(P8)=1KB;
y una memoria de 64 KB divididos en 4 huecos como sigue:
_____
|_____| H1 = 8KB | m(P1)=6KB | H0(P1)=0 | t(P1)=8
|_____| H2 = 8KB | m(P2)=1KB | H0(P2)=0 | t(P2)=8
| | | m(P3)=3KB | H0(P3)=1 | t(P3)=2
|_____| H3 = 16KB | m(P4)=31KB | H0(P4)=0 | t(P4)=2
| | | m(P5)=30KB | H0(P5)=0 | t(P5)=2
| | | m(P6)=2KB | H0(P6)=0 | t(P6)=2
| | H4 = 32KB | m(P7)=4KB | H0(P7)=2 | t(P7)=2
|_____| | m(P8)=1KB | H0(P8)=0 | t(P8)=2

solución:
>: fin del proceso.

| P1| P1| P1| P1| P1| P1| P1| P1| |
H1|---|---|---|---|---|---|---|---> |
| | | | | | | | | |
| P6| P6| P7| P7| P3| P3| | | |
H2|---|--->---|--->---|---> | | |
| | | | | | | | | |
| P2| P2| P2| P2| P2| P2| P2| P2| |
H3|---|---|---|---|---|---|---|---> |
| | | | | | | | | |
| P4| P4| P5| P5| P8| P8| | | |
H4|---|--->---|--->---|---> | | |
|___|___|___|___|___|___|___|___|___|__>
0 1 2 3 4 5 6 7 8 9 t

¿A qué criterio pertenece esta solución?
--[[Usuario:Jorcalmar|Jorcalmar]] 16:42 31 may 2011 (UTC)

Soluciones:

'''a) Mejor ajuste estático''': Asociamos a cada proceso la partición menor en la que cabe. En nuestro caso:
P1: H1
P2: H2
P3: H1/H2 el que acabe primero.
P4: H4
P5: H4
P6: H1/H2 el que acabe primero.
P7: H1/H2 el que acabe primero.
P8: H1/H2 el que acabe primero.

Como vemos, usando este criterio, la partición H3 se queda siempre libre. Éste es uno de los inconvenientes del mejor ajuste estático, no aprovechamos todas las particiones.

| P1| P1| P1| P1| P1| P1| P1| P1| P3| P3| P7| P7
H1|---|---|---|---|---|---|---|--->---|--->---|--->
| | | | | | | | | | | | |
| P2| P2| P2| P2| P2| P2| P2| P2| P6| P6| P8| P8
H2|---|---|---|---|---|---|---|--->---|-->|---|--->
| | | | | | | | | | | | |
| | | | | | | | | | | | |
H3| | | | | | | | | | | | |
| | | | | | | | | | | | |
| P4| P4| P5| P5| | | | | | | | |
H4|---|--->---|---> | | | | | | | |
|___|___|___|___|___|___|___|___|___|__ |___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12

'''b) Primer ajuste:''' En este criterio, elegimos el primer proceso que quepa en la partición que tengamos en la cola de procesos en espera.
Para este criterio, es conveniente verificar en cada instante de tiempo qué procesos tengo en espera (y en qué orden) y qué particiones se me van quedando libres en cada instante.

| P1| P1| P1| P1| P1| P1| P1| P1| | | | |
H1|---|---|---|---|---|---|---|---> | | | |
| | | | | | | | | | | | |
| P2| P2| P2| P2| P2| P2| P2| P2| | | | |
H2|---|---|---|---|---|---|---|---> | | | |
| | | | | | | | | | | | |
| P6| P6| P8| P8| P3| P3| | | | | | |
H3|---|--->---|--->---|---> | | | | | |
| | | | | | | | | | | | |
| P4| P4| P5| P5| P7| P7| | | | | | |
H4|---|--->---|--->---|---> | | | | | |
|___|___|___|___|___|___|___|___|___|__ |___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12

'''c) Mejor ajuste dinámico:'''En este criterio, hemos de seleccionar el mayor proceso que quepa en nuestra partición. Para esto debemos recorrer toda la cola de procesos en espera. Como inconveniente nos encontramos con que los procesos menores quedarán aplazados en favor de los procesos de mayor tamaño. Una vez más debemos tener cuidado verificando el estado de la cola de espera en cada instante de tiempo para la elección de los procesos.

| P1| P1| P1| P1| P1| P1| P1| P1| | | | |
H1|---|---|---|---|---|---|---|---> | | | |
| | | | | | | | | | | | |
| P6| P6| P7| P7| P3| P3| | | | | | |
H2|---|--->---|--->---|---> | | | | | |
| | | | | | | | | | | | |
| P2| P2| P2| P2| P2| P2| P2| P2| | | | |
H3|---|---|---|---|---|---|---|---> | | | |
| | | | | | | | | | | | |
| P4| P4| P5| P5| P8| P8| | | | | | |
H4|---|--->---|--->---|---> | | | | | |
|___|___|___|___|___|___|___|___|___|__ |___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12

Como podemos observar, el proceso 8, queda aplazado hasta que el resto de procesos mayores han terminado. Para solucionar este problema tenemos el siguiente criterio, mayor que quepa con aplazamiento, en el cual hacemos uso de una variable 'umbral' que selecciona aquellos procesos que han sido aplazados un número dado de veces.--[[Usuario:Jorcalmar|Jorcalmar]] 17:43 31 may 2011 (UTC)

Otro ejemplo

2011-05-31T17:42:03Z

Jorcalmar:

Otro ejemplo

2011-05-31T17:15:32Z

Jorcalmar:

Otro ejemplo

2011-05-31T16:42:14Z

Jorcalmar:

SO multiprogramables con particiones variables

2011-05-16T15:08:14Z

Jorcalmar:

== Definición ==

En este tipo de sistemas, las particiones para cada proceso se van creando a medida que son asignadas al procesador. Como ventaja principal tiene que evitamos el desperdicio de memoria dentro de cada bloque ya que cada uno está hecho a medida para el proceso que contiene. Por el contrario, una vez que un proceso ha concluido, su partición se queda en desuso y sería necesario aplicar algoritmos de desfragmentación de memoria para poder unificar todas las partes que han quedado libres y así reciclar las particiones que quedaron huérfanas.

== Elementos de administración ==

* '''Mapas de bits''': Dividiendo la memoria en bloques, se utiliza un bit para representar si dicho bloque está libre o asignado.

* '''Listas de control''': Se almacena en una lista el tamaño de los huecos y las posiciones de memoria entre las que se encuentran comprendidos.

== Criterios de asignación ==

* '''Primer ajuste''': Consiste en asignar el primer hueco disponible que tenga un espacio suficiente para almacenar el programa. Las dos principales desventajas son su alto desperdicio interno, y el elevado uso de las primeras posiciones de memoria. Este último inconveniente repercute negativamente en la circuitería, debido a que se produce un mayor desgaste en dichas posiciones.

* '''Siguiente ajuste''': Se continúa a partir de la posición de la última asignación realizada. De esta forma se resuelve el inconveniente de usar en exceso las primeras posiciones de la memoria.

* '''Mejor ajuste''': Consiste en asignarle al proceso el hueco con menor ajuste interno. Su mayor inconveniente es su orden de complejidad (orden lineal, ''O(n)'')

* '''Peor ajuste''': Al contrario que el criterio anterior, se asigna a cada proceso el hueco con mayor ajuste interno. Tiene el mismo inconveniente en cuanto a orden de complejidad que el mejor ajuste.

* '''Ajuste rápido''': Mediante listas de control, se agrupan los huecos disponibles según su tamaño (0 < t < 10, 10 < t < 20, etc.). De esta manera, cuando se necesite un hueco, se seleccionarán los del grupo del tamaño correspondiente. En el caso de que haya varios huecos disponibles, se seleccionará uno en base a cualquiera de los criterios anteriores.

* '''Método de los compañeros''': Es una variante del ajuste rápido, en el que los huecos se dividen en potencias de 2: 21, 22, ..., 2k. No es un método usado en la práctica, ya que al realizar redondeos a potencias de 2, se produce un elevado desperdicio interno

SO multiprogramables con particiones variables

2011-05-16T15:05:59Z

Jorcalmar:

== Definición ==

En este tipo de sistemas, creamos particiones de memoria a medida que cada proceso va llegando al procesador.
Como ventaja principal, evitamos el desperdicio de memoria dentro de cada bloque ya que cada uno está hecho a medida. Por el contrario, una vez que un proceso ha concluido, su partición se queda en desuso y sería necesario aplicar algoritmos de desfragmentación de memoria para poder unificar todas las partes que han quedado libres.

== Elementos de administración ==

* '''Mapas de bits''': Dividiendo la memoria en bloques, se utiliza un bit para representar si dicho bloque está libre o asignado.

* '''Listas de control''': Se almacena en una lista el tamaño de los huecos y las posiciones de memoria entre las que se encuentran comprendidos.

== Criterios de asignación ==

* '''Primer ajuste''': Consiste en asignar el primer hueco disponible que tenga un espacio suficiente para almacenar el programa. Las dos principales desventajas son su alto desperdicio interno, y el elevado uso de las primeras posiciones de memoria. Este último inconveniente repercute negativamente en la circuitería, debido a que se produce un mayor desgaste en dichas posiciones.

* '''Siguiente ajuste''': Se continúa a partir de la posición de la última asignación realizada. De esta forma se resuelve el inconveniente de usar en exceso las primeras posiciones de la memoria.

* '''Mejor ajuste''': Consiste en asignarle al proceso el hueco con menor ajuste interno. Su mayor inconveniente es su orden de complejidad (orden lineal, ''O(n)'')

* '''Peor ajuste''': Al contrario que el criterio anterior, se asigna a cada proceso el hueco con mayor ajuste interno. Tiene el mismo inconveniente en cuanto a orden de complejidad que el mejor ajuste.

* '''Ajuste rápido''': Mediante listas de control, se agrupan los huecos disponibles según su tamaño (0 < t < 10, 10 < t < 20, etc.). De esta manera, cuando se necesite un hueco, se seleccionarán los del grupo del tamaño correspondiente. En el caso de que haya varios huecos disponibles, se seleccionará uno en base a cualquiera de los criterios anteriores.

* '''Método de los compañeros''': Es una variante del ajuste rápido, en el que los huecos se dividen en potencias de 2: 21, 22, ..., 2k. No es un método usado en la práctica, ya que al realizar redondeos a potencias de 2, se produce un elevado desperdicio interno

SO monoprogramables

2011-05-12T10:31:33Z

Jorcalmar:

La administración de memoria es muy sencilla. El SO se coloca como bloque al principio de la memoria, y el resto para el proceso a ejecutar. Si no cabe, podría recurrirse al solapamiento o a la ejecución en cadena.

Tiene debilidades en cuanto a protección de memoria. Para evitar que un proceso entre en el área del SO, se puede recurrir al uso de bits de protección (se le asocia a cada palabra un bit para comprobar si es de SO o del proceso) o a los registros valla (se conoce el limite de la dirección entre SO y proceso).

Ejemplo práctico:
Pablo tiene una computadora cuya memoria principal tiene una capacidad de 640KB. El SO (MS-DOS) ocupa el principio de la memoria, dejando libre una
zona de 512KB para el proceso conveniente.
Esto nos impide jugar al Sensible Soccer, por ejemplo, ya que ocupa 560KB. Una posible solución seria instalar un SO menos pesado, como una version
más antigua de MS-DOS.

SO monoprogramables

2011-05-12T10:30:11Z

Jorcalmar:

Solución ejercicio 3

2011-05-09T17:22:51Z

Jorcalmar:

La solución no es correcta, ya que se bloquearía el proceso que ejecuta el while del productor y también el del consumidor, y no se avanzaría en la ejecución.
Sería correcto si el semáforo del productor se inicializara a 1.

También habría que asegurar que el proceso P1 comenzará antes que P2, no??
Por lo que seguro que funcionaria con el contador de P1 igual a 1, y contador de P2 igual a 0, no??

R:Creo que no, ya que en caso de que empieze por P2 bloquea a la espera de que algún proceso haga un UP sobre dicho semáforo.

Los procesos son lanzados y tu no sabes a priori qué proceso se va a ejecutar, por lo que tienes que asegurarte que si se ejecuta el consumidor antes que el productor pase a estado bloqueado. Creo que la solución ,tal y como se dice el compañero al principio, es modificar el contador del productor poniendolo a 1.--[[Usuario:Jherrera|Jherrera]]

Lo que he intentado dar a entender en (R:Creo que no, ya que en caso de que empieze por P2 bloquea a la espera de que algún proceso haga un UP sobre dicho semáforo) es lo que tu dices Jherrera.
--[[Usuario:Jorcalmar|Jorcalmar]] 17:22 9 may 2011 (UTC)

Es necesario que el semáforo del productor esté inicializado a 1, para que tenga vía libre para comenzar a producir cuando sea asignado al procesador. Para el correcto funcionamiento, es necesario que el consumidor esté inicializado a 0.

Solución ejercicio 2

2011-05-09T17:11:51Z

Jorcalmar:

X = El proceso pasa a estado bloqueado.
/ = El proceso pasa a estado preparado.
> = Fin de su ejecucion

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

El proceso P1 comienza su ejecucion hasta agotar su ventana de tiempo , luego el proceso P2 bloquea al hacer el down(s2) ya que el semaforo s2 tiene el valor 0 , y como sabemos de los semaforos el proceso se bloquea hasta que no se vuelva a hacer un up(s2). P1 comienza y al hacer un up(s2) pasa p2 a estado preparado , luego al final de la ventana bloquea al hacer down(s1) ya que el contador en ese momento vale 0. Comienza la ejecucion p2 que estaba en estado preparado en el instante T = 10 hace un up(s1) por lo tanto p1 pasa a esta preparado. P1 se ejecuta y finaliza su ejecucion , y luego P2 se ejecuta y finaliza su ejecucion.

--[[Usuario:DvS 013|DvS 013]] 15:30 9 may 2011 (UTC) : las ultimas instrucciones #1 de ambos programas deben ejecutarse para poder ver que i==2 y finalizar el bucle for, no?¿

/ : bloqueado, @: preparado, >: fin del programa, X : se ejecuta el planificador

|i1=0 |i2=0 | i1=1 | i2=1| i1=2| i2=2|
| #1| #2| #3| | | #4| #1| #2| | | | #3| #4| #1| | | | |
P1 |---|---|---| | |---|---|---/ | @ |---|---|---> | | | |
s1 | 1 | 0 | 0 | 1 |
| | | | #1| #2| | | | #3| #4| #1| | | | #2| #3| #4| #1|
P2 | | | |---|---/ @ | |---|---|---| | | |---|---|---|--->
s2 | 0 | 0 | 1 | 0 |
planif 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

--[[Usuario:Josmorgav1|Josmorgav1]] 15:38 9 may 2011 (UTC)
Es correcto, la instrucción #1 si no la ejecuta, no hace la comprobación para continuar o salir del bucle, yo también he hecho el ejercicio en papel, y me da la misma solución que a David Martin.

--[[Usuario:Jorcalmar|Jorcalmar]] 16:33 9 may 2011 (UTC)

Duda acerca de semáforos:

La operación down(s) verifica si el valor del semáforo es 0, si es así, añade el proceso a la lista de procesos bloqueados que tiene el semáforo y si no, contador--. Ahora bien:

¿No sería necesario verificar esta condición por ejemplo en el instante 8? Para verificar si hemos hecho un up que nos permita volver a poner el proceso en preparado. Con verificar me refiero volver a realizar la llamada.

--[[Usuario:Josmorgav1|Josmorgav1]] 16:57 9 may 2011 (UTC)
No entiendo bien tu pregunta, pero como aclaración te digo, que respecto al down(s) es correcta la definición que has dado.
Para el caso del instante 8, realizas un up(s) que por definición, si no tiene procesos en la lista de semáforo, incrementa la variable (s++), en caso de tener algún proceso en esa lista, implica que estaría bloqueado, por lo cual, al hacer el up(s), se pone el proceso en modo preparado, y no se incrementa el contador, ya que al hacer up(s) permitimos que entre otro proceso en la sección crítica, pero a la vez, si está en la lista de semáforo, ya estamos "preparando" el proceso que entrará en la sección crítica, por eso se mantiene el semáforo con el valor que tenía antes del up(s).
Espero que haya servido de aclaración, aunque el up(s) es un poco enredoso.

Ok gracias, me has respondido a la duda, el hecho de poner el estado en proceso preparado viene implicitamente dentro de la operacion UP. Muchas gracias.--[[Usuario:Jorcalmar|Jorcalmar]] 17:11 9 may 2011 (UTC)

Solución ejercicio 1

2011-05-09T16:55:45Z

Jorcalmar:

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

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

El proceso P2 comienza su ejecucion y al hacer el down al semaforo s2 que vale 0 bloquea , ya que los semaforo es un sincronizacion bloqueante, p1 comienza su ejecucion hasta que se hace up(s2) y agota su ventana de tiempo y p2 puede comenzar su ejecucion.

--[[Usuario:DvS 013|DvS 013]] 15:09 9 may 2011 (UTC) : había conflicto cuando le he dado a subir así que pongo debajo lo que yo estaba editando antes de que se subiera nada
p1: <source lang="c">
for (int i=0; i<2; i++) { #1
down(s1); #2
f1(); #3
if (get(s1) == 0) #4
up(s2); #5
} </source>
P2: <source lang="c">
for (int i=0; i<2; i++) { #1
down(s2); #2
f2(); #3
up(s1); #4
} </source>

X : se ejecuta el planificador
> : fin del proceso
#nº : número de insturcción

|i2=0 |i1=0 | i2=1 | i1=1 | | i2=2|i1=2 |
| | | | #1| #2| #3| | | | #4| #1| #2| #3| #4| #5| | | | #1| |
P1 | | | |---|---|---| | | |---|---|---|---|---|---| | | |---> |
s1 | 1 | 0 | 1 | 0 | 1 | |
| #1| #2| #3| | | | #4| #1| #2| | | | | | | #3| #4| #1| | |
P2 |---|---|---| | | |---|---|---| | | | | | |---|---|---> | |
s2 | 1 | 0 | 0 | | | | | |
planif 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

Nueva solución:
Con respecto a la primera, una simple aclaración --[[Usuario:David|David]] 15:26 9 may 2011 (UTC)
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

Como aclaración: cuando se realiza el up de un semáforo que vale 0, si hay procesos en su lista de semáforos, se coge el primero y se pasa a estado preparado, valiendo el contador del semáforo 0, por eso en el instante 15 al hacer el down de s2 vuelve a bloquear.

--[[Usuario:Josmorgav1|Josmorgav1]] 15:32 9 may 2011 (UTC)
Una aclaración al compañero David Martin, el contador de semáforo s2, en un principio vale 0, y como el primer proceso en ejecutar es P2, al hacer el down(s2); bloquea, creo que en tu solución consideras que s2 vale 1.
Desde mi punto de vista, la solución por ahora más correcta, es la del compañero David Suárez

--[[Usuario:Jherrera|Jherrera]]
Con respecto a la solución de Dvs no es correcta a partir del instante 2, ya que interpreto que el proceso 2 ejecuta la instrucción nº3 en vez de pasar a bloqueado. He realizado el ejercicio al igual que David (última solución propuesta) y pienso que está totalmente correcto.

--[[Usuario:Jorcalmar|Jorcalmar]] 16:55 9 may 2011 (UTC)
La última solución propuesta coincide con la que me ha salido a mí, espero que esté bien.

Solución ejercicio 1

2011-05-09T16:55:15Z

Jorcalmar:

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

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

El proceso P2 comienza su ejecucion y al hacer el down al semaforo s2 que vale 0 bloquea , ya que los semaforo es un sincronizacion bloqueante, p1 comienza su ejecucion hasta que se hace up(s2) y agota su ventana de tiempo y p2 puede comenzar su ejecucion.

--[[Usuario:DvS 013|DvS 013]] 15:09 9 may 2011 (UTC) : había conflicto cuando le he dado a subir así que pongo debajo lo que yo estaba editando antes de que se subiera nada
p1: <source lang="c">
for (int i=0; i<2; i++) { #1
down(s1); #2
f1(); #3
if (get(s1) == 0) #4
up(s2); #5
} </source>
P2: <source lang="c">
for (int i=0; i<2; i++) { #1
down(s2); #2
f2(); #3
up(s1); #4
} </source>

X : se ejecuta el planificador
> : fin del proceso
#nº : número de insturcción

|i2=0 |i1=0 | i2=1 | i1=1 | | i2=2|i1=2 |
| | | | #1| #2| #3| | | | #4| #1| #2| #3| #4| #5| | | | #1| |
P1 | | | |---|---|---| | | |---|---|---|---|---|---| | | |---> |
s1 | 1 | 0 | 1 | 0 | 1 | |
| #1| #2| #3| | | | #4| #1| #2| | | | | | | #3| #4| #1| | |
P2 |---|---|---| | | |---|---|---| | | | | | |---|---|---> | |
s2 | 1 | 0 | 0 | | | | | |
planif 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

Nueva solución:
Con respecto a la primera, una simple aclaración --[[Usuario:David|David]] 15:26 9 may 2011 (UTC)
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

Como aclaración: cuando se realiza el up de un semáforo que vale 0, si hay procesos en su lista de semáforos, se coge el primero y se pasa a estado preparado, valiendo el contador del semáforo 0, por eso en el instante 15 al hacer el down de s2 vuelve a bloquear.

--[[Usuario:Josmorgav1|Josmorgav1]] 15:32 9 may 2011 (UTC)
Una aclaración al compañero David Martin, el contador de semáforo s2, en un principio vale 0, y como el primer proceso en ejecutar es P2, al hacer el down(s2); bloquea, creo que en tu solución consideras que s2 vale 1.
Desde mi punto de vista, la solución por ahora más correcta, es la del compañero David Suárez

--[[Usuario:Jherrera|Jherrera]]
Con respecto a la solución de Dvs no es correcta a partir del instante 2, ya que interpreto que el proceso 2 ejecuta la instrucción nº3 en vez de pasar a bloqueado. He realizado el ejercicio al igual que David (última solución propuesta) y pienso que está totalmente correcto.
----
La última solución propuesta coincide con la que me ha salido a mí, espero que esté bien :P

Solución ejercicio 2

2011-05-09T16:33:03Z

Jorcalmar:

Solución de los ejercicios de concurrencia

2011-05-09T11:32:22Z

Jorcalmar:

| #1| #2| #3| | | | #4| #1| #2| | | | #3| #4|El programa ya termina |
H1 |---|---|---| | | |---|---|---| | | |---|---|---| | | | | |
| | | | | | | | | | | | | | | | | | | | |
| | | | #1| #2| #2| | | | #2| #2| #2| | | | #2| #3| #4| #1| #2| #3| #4| El programa termina.
H2 | | | |---|---|---| | | |---|---|---| | | |---|---|---|---| |
| | | | | | | | | | | | | | | | | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

En este ejercicio, el hilo 2 se queda esperando continuamente a que el hilo 1 libere el cerrojo para poder acceder a la función.
El programa finaliza en el hilo 1 cuando llega dos veces a la instrucción 4 (bucle for).

Modificación:

Solución:

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

Solución de los ejercicios de concurrencia

2011-05-09T11:22:00Z

Jorcalmar: Página nueva: | #1| #2| #3| | | | #4| #2| #3| | | | #4| El programa ya termina| H1 |---|---|---| | | |---|---|---| | | |---|---|---| | | | | | ...

| #1| #2| #3| | | | #4| #2| #3| | | | #4| El programa ya termina|
H1 |---|---|---| | | |---|---|---| | | |---|---|---| | | | | |
| | | | | | | | | | | | | | | | | | | | |
| | | | #1| #2| #2| | | | #2| #2| #2| | | | | | | | |
H2 | | | |---|---|---| | | |---|---|---| | | | | | | | |
| | | | | | | | | | | | | | | | | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

En este ejercicio, el hilo 2 se queda esperando continuamente a que el hilo 1 libere el cerrojo para poder acceder a la función.
El programa finaliza en el hilo 1 cuando llega dos veces a la instrucción 4 (bucle for).

Sol-ejer2-planif-procesos

2011-03-21T15:48:04Z

Jorcalmar: /* Turno rotatorio */

= Turno rotatorio =

____|_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__|

Sigue estando mal, el quantum no se reduce a 1 en el proceso A, el quantum se debe respetar siempre(en el articulo de la wiki sobre turno rotatorio lo explican).

Pd: No pises las otras soluciones propuestas, pon la tuya debajo para que todos podamos discutirlo.

< = indica el instante de lanzamiento del proceso
> = indica el instante de finalización del proceso
X = se ejecuta el código del planificador
/ = Tiempo del quantum desaprovechado bien por bloqueo de E/S o por finalización del proceso.

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

= 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

 | | | | | | | | | | | | | | | | | | | | |
PA <---| | |---| | |---> | | | | | | | | | | | | |
PB | <---| | |---| | |---| | |---| |---> | | | | | | |
PC | | <---| | |---| | |---|---| |---| |---> | | | | | |
Planificador X 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

_____|_PA_|_PB_|_PC_|
Cálculos __t__|_3__|_5__|_6__|
de tiempos __T__|_7__|_12_|_12_|
_T/t_|2.3_|2.4_|_2__|

=============
Observaciones
=============

- Al no existir en el instante de tiempo 0 problemas de concurrencia de procesos, ¿no debería el proceso A tener derecho a sus dos unidades de tiempo de quantum, aunque este solo utilice una unidad de tiempo debido al bloqueo por E/S?. Esto dejaría al procesador con dos procesos en estado preparado (B y C) en el instante de tiempo 2, donde ya se reduciría el quantum a 1 debido a la existencia de 2 o más procesos en estado preparado. ¿Cómo lo veis?

Usuario discusión:Jorcalmar

2011-03-21T15:41:01Z

Jorcalmar:

Si no lo había leído lo de A y B lo estaba corrigiendo cuando al darle a guardar me decía que había colisión y suerte que me ha dejado copiarlo y ponerlo de nuevo.
Por eso he pegado la solución corregida encima de tu corrección.

Ok, voy a verlo, espero que sea lo mismo porque si no, vaya lio!

Sol-ejer2-planif-procesos

2011-03-21T15:28:31Z

Jorcalmar:

= Turno rotatorio =

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

| | | | | | | | | | | | | | | | | | | |
PA <---|---| | | | |---> | | | | | | | | | | | |
PB | < |---|---| | | |---|---| | |---> | | | | | | |
PC | | < | |---|---| | | |---|---| |---|---> | | | | |
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

_____|_PA_|_PB_|_PC_|
Cálculos __t__|_3__|_5__|_6__|
de tiempos __T__|_7__|_11_|_12_|
_T/t_|2.3_|2.2_|_2__|

En esta solución propuesta no se ha tenido en cuenta el bloqueo que sufre el proceso A cuando lleva una unidad de tiempo 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
/ = Tiempo del quantum no aprovechado debido a bloqueo o a la finalización del proceso.
| | | | | | | | | | | | | | | | | | | |
PA <---|///| | | | |---|///| | | | |---|///> | | | | |
PB | < |---|---| | | | |---|---| | | | |---|///> | | |
PC | | < | |---|---| | | | |---|---| | | | |---|---> |
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

= 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

 | | | | | | | | | | | | | | | | | | | | |
PA <---| | |---| | |---> | | | | | | | | | | | | |
PB | <---| | |---| | |---| | |---| |---> | | | | | | |
PC | | <---| | |---| | |---|---| |---| |---> | | | | | |
Planificador X 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

_____|_PA_|_PB_|_PC_|
Cálculos __t__|_3__|_5__|_6__|
de tiempos __T__|_7__|_12_|_12_|
_T/t_|2.3_|2.4_|_2__|

=============
Observaciones
=============

- Al no existir en el instante de tiempo 0 problemas de concurrencia de procesos, ¿no debería el proceso A tener derecho a sus dos unidades de tiempo de quantum, aunque este solo utilice una unidad de tiempo debido al bloqueo por E/S?. Esto dejaría al procesador con dos procesos en estado preparado (B y C) en el instante de tiempo 2, donde ya se reduciría el quantum a 1 debido a la existencia de 2 o más procesos en estado preparado. ¿Cómo lo veis?

Sol-ejer2-planif-procesos

2011-03-21T15:24:24Z

Jorcalmar: Observación acerca de la solución propuesta por otro alumno.

= Turno rotatorio =

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

| | | | | | | | | | | | | | | | | | | |
PA <---|---| | | | |---> | | | | | | | | | | | |
PB | < |---|---| | | |---|---| | |---> | | | | | | |
PC | | < | |---|---| | | |---|---| |---|---> | | | | |
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

_____|_PA_|_PB_|_PC_|
Cálculos __t__|_3__|_5__|_6__|
de tiempos __T__|_7__|_11_|_12_|
_T/t_|2.3_|2.2_|_2__|

En esta solución propuesta no se ha tenido en cuenta el bloqueo que sufre el proceso A cuando lleva una unidad de tiempo 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
/ = Tiempo del quantum no aprovechado debido a bloqueo.
| | | | | | | | | | | | | | | | | | | |
PA <---|///| | | | |---|///| | | | |---|///> | | | | |
PB | < |---|---| | | | |---|---| | | | |---|///> | | |
PC | | < | |---|---| | | | |---|---| | | | |---|---> |
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

= 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

 | | | | | | | | | | | | | | | | | | | | |
PA <---| | |---| | |---> | | | | | | | | | | | | |
PB | <---| | |---| | |---| | |---| |---> | | | | | | |
PC | | <---| | |---| | |---|---| |---| |---> | | | | | |
Planificador X 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

_____|_PA_|_PB_|_PC_|
Cálculos __t__|_3__|_5__|_6__|
de tiempos __T__|_7__|_12_|_12_|
_T/t_|2.3_|2.4_|_2__|

=============
Observaciones
=============

- Al no existir en el instante de tiempo 0 problemas de concurrencia de procesos, ¿no debería el proceso A tener derecho a sus dos unidades de tiempo de quantum, aunque este solo utilice una unidad de tiempo debido al bloqueo por E/S?. Esto dejaría al procesador con dos procesos en estado preparado (B y C) en el instante de tiempo 2, donde ya se reduciría el quantum a 1 debido a la existencia de 2 o más procesos en estado preparado. ¿Cómo lo veis?

Sol-ejer2-planif-procesos

2011-03-21T15:06:01Z

Jorcalmar: Observación acerca de la solución propuesta por otro alumno.

= 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

 | | | | | | | | | | | | | | | | | | | | |
PA <---| | |---| | |---> | | | | | | | | | | | | |
PB | <---| | |---| | |---| | |---| |---> | | | | | | |
PC | | <---| | |---| | |---|---| |---| |---> | | | | | |
Planificador X 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

_____|_PA _|_PB_|_PC _|
Cálculos __t__|_3__|_5__|_6__|
de tiempos __T__|_7__|_12_|_12_|
_T/t_|2.3_|2.4_|_2__|

=============
Observaciones
=============

- Al no existir en el instante de tiempo 0 problemas de concurrencia de procesos, ¿no debería el proceso A tener derecho a sus dos unidades de tiempo de quantum, aunque este solo utilice una unidad de tiempo debido al bloqueo por E/S?. Esto dejaría al procesador con dos procesos en estado preparado (B y C) en el instante de tiempo 2, donde ya se reduciría el quantum a 1 debido a la existencia de 2 o más procesos en estado preparado. ¿Cómo lo veis?

Hilos

2011-02-26T21:40:08Z

Jorcalmar: Página nueva: En un sistema basado en '''hilos''', los procesos poseen internamente varias líneas (hilos) de ejecución, en contraposición de la visión clásica de la ejecución lineal. Dentro ...

En un sistema basado en '''hilos''', los procesos poseen internamente varias líneas (hilos) de ejecución, en contraposición de la visión clásica de la ejecución lineal.

Dentro de los programas, con frecuencia, aparecen ciertos sectores independientes entre sí. En un sistema con multiprogramación, podemos tomar cada sección como procesos independientes ya que la permutación en el orden de ejecución no altera el resultado final. Si alguna de estas secciones presentase algún estado de bloqueo, se sumaría al tiempo global de todo el proceso. Éste tiempo se vería reducido al encontrarnos en un sistema multiprogramado.

Ésta división en múltiples procesos provoca que en memoria se deba reservar un espacio para cada uno y que tras la consecución de cada uno, haya que reunirse todos los resultados en un único espacio de memoria. Otra opción para evitar este problema es el uso de un espacio de memoria común, pero traería consigo problemas de permisos y protección de memoria.

El concepto de '''hilo''' aparece para arreglar estos problemas:

Las líneas internas del proceso se desarrollan sobre el mismo espacio de memoria (la asignada al proceso original). Al ser líneas de ejecución diferentes, poseen su puntero de instrucción, sus valores para los registros de trabajo y su propia pila. No existe la protección entre las diferentes líneas de ejecución, por lo que una sola línea podría destruir el trabajo de las demás. El buen resultado de las líneas depende del programador.

Al usar un espacio de memoria común, la comunicación entre los hilos es más directa que entre procesos independientes con su propio espacio reservado.

La implantación del concepto de hilo provoca que en el sistema operativo sea necesaria la creación de llamadas al sistema referentes a él, tales como: creación de hilos, destrucción de hilos, suspensión, esperas, etc.

El mismo sistema operativo usa el sistema de hilos para la programación de sus actividades.

Bloque de control de procesos

2011-02-26T20:35:29Z

Jorcalmar: Página nueva: Para llevar acabo la gestión de un proceso, es necesario que el sistema operativo guarde cierta información necesaria. A ésta estructura se le conoce como '''el bloque de control ...

Para llevar acabo la gestión de un proceso, es necesario que el sistema operativo guarde cierta información necesaria. A ésta estructura se le conoce como '''el bloque de control del proceso o PCB (Process Control Block)'''.

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

. Identificación del proceso: Para identificar el proceso se puede utilizar tanto como un nombre como un número de identificación conocido como pid (process identification number). A veces se usan ambos.

. Prioridad del proceso o el tipo.

. Estado del proceso para el planificador (preparado, activo, suspendido, etc.).

. Estado actual del procesador (registros, bits de estados, etc.)

. Información y estadísticas sobre la planificación y la utilización de los recursos.

. Información de la gestión de memoria (tablas, mapas, registros, etc.).

. Estado de L/E (asignación de dispositivos, operaciones en espera).

. Información de los archivos abiertos.