Ejercicios sincronización y comunicación

Ejercicio 1

Realice el cronograma temporal que represente la ejecución de dos procesos P1 y P2. El proceso P1 ejecuta el siguiente código:

for (int i=0; i<2; i++) {  /* #1 */
    down(s1);              /* #2 */
    f1();                  /* #3 */
    if (get(s1) == 0)      /* #4 */
        up(s2);            /* #5 */
}

Y el proceso P2 ejecuta el siguiente código:

for (int i=0; i<2; i++) {  /* #1 */
    down(s2);              /* #2 */
    f2();                  /* #3 */
    up(s1);                /* #4 */
}

Para el semáforo s1 el contador vale 1, mientras que para el semáforo s2 el contador vale 0.

Suponga que:

• El planificador emplea turno rotatorio estricto con quantum de 3 unidades de ejecución.
• Se sabe que el proceso P2 es seleccionado en primer lugar por el planificador para ejecutarse.
• La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las líneas de código toman el mismo tiempo de ejecución.
• La función get(semáforo s) devuelve el valor del contador del semáforo.

El cronograma deberá incluir qué línea de código se ejecuta en cada unidad de ejecución.

Ver solución del ejercicio 1

Ejercicio 2

Realice el cronograma temporal que represente la ejecución de dos procesos P1 y P2. El proceso P1 ejecuta el siguiente código:

for (int i=0; i<2; i++) { /* #1 */
    down(s1);             /* #2 */
    f1();                 /* #3 */
    up(s2);               /* #4 */
}

Y el proceso P2 ejecuta el siguiente código:

for (int i=0; i<2; i++) { /* #1 */
    down(s2);             /* #2 */
    f2();                 /* #3 */
    up(s1);               /* #4 */
}

Para el semáforo s1 el contador vale 1, mientras que para el semáforo s2 el contador vale 0.

Suponga que:

• El planificador emplea turno rotatorio estricto con quantum de 3 unidades de ejecución.
• Se sabe que el proceso P1 es seleccionado en primer lugar por el planificador para ejecutarse.
• La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las instrucciones toman el mismo tiempo de ejecución.

El cronograma deberá incluir qué instrucción se ejecuta en cada unidad de ejecución.

Ver solución del ejercicio 2

Ejercicio 3

En un examen de sistemas operativos, un estudiante plantea la siguiente solución basada en dos procesos, un proceso P1 productor y un proceso P2 consumidor, en el que el contador de los semáforos s1 y s2 valen inicialmente 0.

while(1) {
    down(s1);
    produce();
    up(s2);
}

Y el proceso P2 ejecuta el siguiente código:

while(1) {
    down(s2);
    consume();
    up(s1);
}

Responda brevemente si la solución que propone es idónea justificando su respuesta.

Ver solución del ejercicio 3

Ejercicio 4

Realice el cronograma temporal que represente la ejecución de dos procesos P1 y P2. El proceso P1 ejecuta el siguiente código:

for (int i=0; i<2; i++) {  /* #1 */
    send(msg, P2);         /* #2 */
    recv(msg, P2);         /* #3 */
}

Y el proceso P2 ejecuta el siguiente código:

for (int i=0; i<2; i++) {  /* #1 */
    recv(msg, P1);         /* #2 */
    send(msg, P1);         /* #3 */
}

Suponga que:

• El planificador emplea turno rotatorio estricto con quantum de 3 unidades de ejecución.
• Se sabe que el proceso P1 es seleccionado en primer lugar por el planificador para ejecutarse.
• La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las instrucciones toman el mismo tiempo de ejecución.
• El comportamiento de la primitiva send() es síncrono y el la primitiva recv() es bloqueante.
• Suponga que msg contiene un mensaje que se emplea como testigo y cuyo contenido no tiene relevancia.

El cronograma deberá incluir qué instrucción se ejecuta en cada unidad de ejecución.

Ver solución del ejercicio 4

Ejercicio 5

Realice el cronograma temporal que represente la ejecución de dos procesos P1 y P2. El proceso P1 ejecuta el siguiente código:

for (int i=0; i<2; i++) { /* #1 */
    down(s1);             /* #2 */
    f1();                 /* #3 */
    up(s2);               /* #4 */
}

Y el proceso P2 ejecuta el siguiente código:

for (int i=0; i<2; i++) { /* #1 */
    down(s2);             /* #2 */
    f2();                 /* #3 */
    up(s1);               /* #4 */
}

Para el semáforo s1 el contador vale 1, mientras que para el semáforo s2 el contador vale 0.

Suponga que:

• El planificador emplea turno rotatorio estricto, con quantum ilimitado, por tanto, un proceso se mantiene en estado activo hasta que realice una operación bloqueante.
• Se sabe que el proceso P2 es seleccionado en primer lugar por el planificador para ejecutarse.
• La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las instrucciones toman el mismo tiempo de ejecución.

El cronograma deberá incluir qué instrucción se ejecuta en cada unidad de ejecución.

Ver solución del ejercicio 5

Ejercicio 6

Dado dos procesos P1 y P2 cuyos códigos son los siguientes:

Código del Proceso 1:

for (int i=0; i<2; i++) {   /* #1 */
    send(msg);              /* #2 */
    f(msg);                 /* #3 */
    recv(msg);              /* #4 */
}

Código del Proceso 2:

for (int i=0; i<2; i++) {   /* #1 */
    recv(msg);              /* #2 */
    f(msg);                 /* #3 */
    send(msg);              /* #4 */
}

Suponga que:

• El planificador emplea turno rotatorio estricto con quantum de 3 unidades de ejecución.
• Se sabe que el proceso P1 es seleccionado en primer lugar por el planificador para ejecutarse.
• La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las instrucciones toman el mismo tiempo de ejecución.
• El comportamiento de la primitiva send() es asíncrono y el de la primitiva recv() es bloqueante.
• Suponga que msg contiene un mensaje inicialmente bien formado cuyo contenido no tiene relevancia

El cronograma deberá incluir qué instrucción se ejecuta en cada unidad de ejecución.

Ver solución del ejercicio 6

Ejercicio 7

En base a dos hilos h1 y h2 de un mismo proceso P cuyos codigos son los siguientes:

En el hilo h1 se ejecuta el siguiente código:

for (int i = 0; i<2; i++){ //#1
   while(cerrojo_p2);      //#2
      cerrojo_p1 = 1;      //#3
      f();                 //#4
      cerrojo_p1 = 0;      //#5

}

for (int i = 0; i<2; i++){ //#1
   while(cerrojo_p1);      //#2
      cerrojo_p2 = 1;      //#3
      f();                 //#4
      cerrojo_p2 = 0;      //#5

}

Proponga una solución en la que se reemplacen los cerrojos por semáforos. Realice el cronograma temporal de ejecución de la solución que propone.

Siendo cerrojo_p1 y cerrojo_p2 variables globales inicialmente a cero.

Migoligon 17:57 4 dic 2011 (UTC)Creí que en el ejercicio 3 quedó claro que no debian iniciarse ambas a 0 porque era un error garrafal. Y ahora me encuentro esto y en las soluciones no diferencia s1 de s2, además de que la solución está preparada para que sea s1 = 1 y s2 = 0 no se de donde han sacado los datos para hacer la solución pero no creo que desde aqui.

Supongamos que:

• El planificador emplea turno rotatorio estricto con quantum de 3 unidades de ejecución.
• Se sabe que el hilo h1 es seleccionado en primer lugar por el planificador para ejecutarse.
• La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las instrucciones toman el mismo tiempo de ejecución.

el planificador

Juacordia 16:33 5 dic 2011

Hola Migoligon creo que estas confundiendo cerrojos por semaforos, una cosa es que los semaforos no puedan estar inicializados a cero y otra son los cerrojos. Espero haberte ayudado. PD: Los semaforos puedes ponerlos de otra manera.

Ver solución del ejercicio 7

Ejercicio 8

Realice el cronograma temporal que represente la ejecución de dos procesos P1 y P2. El proceso P1 ejecuta el siguiente código:

for (int i=0; i<2; i++) { /* #1 */
    down(s1);             /* #2 */
    f1();                 /* #3 */
    up(s1);               /* #4 */
}

Y el proceso P2 ejecuta el siguiente código:

for (int i=0; i<2; i++) { /* #1 */
    down(s2);             /* #2 */
    f2();                 /* #3 */
    up(s2);               /* #4 */
}

Suponiendo que los contadores de los semáforos s1 y s2 valen 1.

Suponga que:

• El planificador emplea turno rotatorio estricto con quantum de 3 unidades de ejecución.
• Se sabe que el proceso P1 es seleccionado en primer lugar por el planificador para ejecutarse.
• La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las instrucciones toman el mismo tiempo de ejecución.

El cronograma deberá incluir qué instrucción se ejecuta en cada unidad de ejecución.

Ver solución del ejercicio 8

Ejercicio 9

Realice el cronograma temporal que represente la ejecución de dos procesos P1 y P2. El proceso P1 ejecuta el siguiente código:

for (int i=0; i<2; i++) { /* #1 */
    down(s);             /* #2 */
    f1();                 /* #3 */
    up(s);               /* #4 */
}

Y el proceso P2 ejecuta el siguiente código:

for (int i=0; i<2; i++) { /* #1 */
    down(s);             /* #2 */
    f2();                 /* #3 */
    up(s);               /* #4 */
}

Suponiendo que el contador del semáforo s vale 1.

Suponga que:

• El planificador emplea turno rotatorio estricto con quantum de 3 unidades de ejecución.
• Se sabe que el proceso P1 es seleccionado en primer lugar por el planificador para ejecutarse.
• La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las instrucciones toman el mismo tiempo de ejecución.

El cronograma deberá incluir qué instrucción se ejecuta en cada unidad de ejecución.

Ver solución del ejercicio 9

6.1 Definición de interbloqueo