Solución ejercicio 2 - Historial de revisiones

Juagommat en 10:47 4 dic 2017

2017-12-04T10:47:55Z

Pneira: revisión del profesor (3)

2011-05-10T09:24:39Z

revisión del profesor (3)

Pneira: revisión del profesor (2)

2011-05-10T09:24:18Z

revisión del profesor (2)

Pneira: revisión del profesor

2011-05-10T09:23:58Z

revisión del profesor

Jorcalmar en 17:11 9 may 2011

2011-05-09T17:11:51Z

Josmorgav1: respuesta a la duda

2011-05-09T16:57:14Z

respuesta a la duda

Jorcalmar en 16:33 9 may 2011

2011-05-09T16:33:03Z

Josmorgav1: Aclaración compañeros

2011-05-09T15:38:33Z

Aclaración compañeros

DvS 013 en 15:30 9 may 2011

2011-05-09T15:30:58Z

Fcoramlop en 15:06 9 may 2011

2011-05-09T15:06:37Z

@@ Línea 14: / Línea 14: @@
 Observaciones:
-* El proceso P1 comienza su ejecucion hasta agotar su ventana de tiempo. Tras esto, el proceso P2 tiene su oportunidad de ejecución pero bloquea al hacer el down del semáforo s2 cuyo contador vale 0 (instante de tiempo 5). El proceso P2 volverá a pasar a estado preparado en cuanto el proceso P1 realice up sobre el semáforo s2.
+* El proceso P1 comienza su ejecución hasta agotar su ventana de tiempo. Tras esto, el proceso P2 tiene su oportunidad de ejecución, pero bloquea al hacer el down del semáforo s2 cuyo contador vale 0 (instante de tiempo 5). El proceso P2 volverá a pasar a estado preparado en cuanto el proceso P1 realice up sobre el semáforo s2.
 * La instrucción #1 se tiene que ejecutar en el intento de tercera iteración para comprobar la condición de fin del bucle.

@@ Línea 15: / Línea 15: @@
 Observaciones:
 * El proceso P1 comienza su ejecucion hasta agotar su ventana de tiempo. Tras esto, el proceso P2 tiene su oportunidad de ejecución pero bloquea al hacer el down del semáforo s2 cuyo contador vale 0 (instante de tiempo 5). El proceso P2 volverá a pasar a estado preparado en cuanto el proceso P1 realice up sobre el semáforo s2.
-* Es correcto, la instrucción #1 se tiene que ejecutar en el intento de tercera iteración para comprobar la condición de fin del bucle.
+* La instrucción #1 se tiene que ejecutar en el intento de tercera iteración para comprobar la condición de fin del bucle.
 --[[Usuario:Pneira|Pneira]] 09:24 10 may 2011 (UTC)

@@ Línea 17: / Línea 17: @@
 * Es correcto, la instrucción #1 se tiene que ejecutar en el intento de tercera iteración para comprobar la condición de fin del bucle.
-Comentarios de estudiantes:
+--[[Usuario:Pneira|Pneira]] 09:24 10 may 2011 (UTC)
-= Duda acerca de semáforos =
+= Comentarios de estudiantes =
 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:

@@ Línea 2: / Línea 2: @@
        / = El proceso pasa a estado preparado.
        > = Fin de su ejecucion
-−
-−
-       | #1| #2| #3|   |   | #4| #1| #2|   |   |   | #3| #4|   |   |   |   |   |   |   |
+       | #1| #2| #3|   |   | #4| #1| #2|   |   |   | #3| #4| #1|   |   |   |   |   |   |
-     p1|---|---|---|   |   |---|---|---X   |   /   |---|--->   |   |   |   |   |   |   |
+     P1|---|---|---|   |   |---|---|---X   |   /   |---|---|--->   |   |   |   |   |   |
        |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |
-       |   |   |   | #1| #2|   |   |   | #3| #4| #1|   |   | #2| #3| #4|   |   |   |   |
+       |   |   |   | #1| #2|   |   |   | #3| #4| #1|   |   |   | #2| #3| #4| #1|   |   |
-     p2|   |   |   |---|---X   /   |   |---|---|---|   |   |---|---|--->   |   |   |   |
+     P2|   |   |   |---|---X   /   |   |---|---|---|   |   |   |---|---|------->   |   |
        |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |
        |___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
    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.
+Observaciones:
+* El proceso P1 comienza su ejecucion hasta agotar su ventana de tiempo. Tras esto, el proceso P2 tiene su oportunidad de ejecución pero bloquea al hacer el down del semáforo s2 cuyo contador vale 0 (instante de tiempo 5). El proceso P2 volverá a pasar a estado preparado en cuanto el proceso P1 realice up sobre el semáforo s2.
---[[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?¿
+* Es correcto, la instrucción #1 se tiene que ejecutar en el intento de tercera iteración para comprobar la condición de fin del bucle.
---[[Usuario:Jorcalmar|Jorcalmar]] 16:33 9 may 2011 (UTC)
+Comentarios de estudiantes:
-Duda acerca de semáforos:
+= 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:

← Revisión anterior		Revisión del 17:11 9 may 2011
Línea 49:		Línea 49:
	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).		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.		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)

← Revisión anterior		Revisión del 16:57 9 may 2011
Línea 43:		Línea 43:

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

← Revisión anterior		Revisión del 16:33 9 may 2011
Línea 33:		Línea 33:
	--[[Usuario:Josmorgav1\|Josmorgav1]] 15:38 9 may 2011 (UTC)		--[[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.		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.

← Revisión anterior		Revisión del 15:38 9 may 2011
Línea 29:		Línea 29:
	\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|		\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|
	0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18		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.

← Revisión anterior		Revisión del 15:30 9 may 2011
Línea 14:		Línea 14:

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

← Revisión anterior		Revisión del 15:06 9 may 2011
Línea 12:		Línea 12:
	\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|		\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|___\|
	0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20		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.