Final Concurrente

Si el algoritmo se ejecuta secuencialmente se tienen:

• Asignaciones: 128^3 + 128^2 = 2097152 + 16384 = 2113536
• Sumas: 128^3 = 2097152.
• Productos: 128^3 = 2097152.

Si tenemos 8 procesos cada uno con un strip de 16 (128/8) los cálculos de tiempo quedarían para cada proceso como:

• Asignaciones: 128^2 * 16 + 128 * 16 = 262144 + 2048 = 264192.
• Sumas: 128^2 * 16 = 262144.
• Productos: 128^2 * 16 = 262144

Con S&C un proceso que es despertado para poder seguir ejecutando es pasado a la cola de ready en cuyo caso su orden de ejecución depende de la política que se utilice para ordenar los procesos en dicha cola. Puede ser que sea retrasado en esa cola permitiendo que otro proceso ejecute en el monitor antes que el por lo que podría no cumplirse el objetivo del SJN.

En cambio, con S&W se asegura que el proceso despertado es el próximo en ejecutar después de que el señalador ejecuta signal. Por lo tanto, SJN funcionaria correctamente de esta forma evitando que cualquier otro proceso listo para ejecutar le robe el acceso al proceso despertado

Definiciones:

• Signal and Continue -> el proceso que hace el signal continua usando el monitor, y el proceso despertado pasa a competir por acceder nuevamente al monitor para continuar con su ejecución (en la instrucción que lógicamente le sigue al wait).
• Signal and Wait -> el proceso que hace el signal pasa a competir por acceder nuevamente al monitor, mientras que el proceso despertado pasa a ejecutar dentro del monitor a partir de instrucción que lógicamente le sigue al wait.

monitor Semaforo{ 
    int s = 1, espera = 0; cond pos;

    procedure P (){ 
        if (s == 0) {
            espera ++; 
            wait(pos);
        }
        else
            s = s-1;
    };

    procedure V () {
        if (espera == 0 ) 
            s = s+1
        else { 
            espera --; 
            signal(pos);
        }
    };
};

monitor Controlador_ListaEnlazada{
    int numSearchers=0, numInserters=0, numDeleters =0;
    cond searchers, inserters, deleters;

    procedure pedir_Deleter(){
        while (numSearchers>0 OR numInserters>0 OR numDeleters >0){
            wait(deleters);
        }
        numDeleters=numDeleters+1;
    }
    procedure liberar_Deleter(){
        numDeleters=numDeleters-1;
        signal(inserters);
        signal(deleters);
        signal_all(searchers);
    }
    procedure pedir_Searcher(){
        while(numDeleters >0){ 
            wait(searchers);
        }
        numSearchers=numSearchers+1;
    }
    procedure liberar_Searcher(){
        numSearchers=numSearchers-1;
        if(numSearchers==0 AND numInserters==0 ){
            signal(deleters);
        }
    }
    procedure pedir_Inserter(){
        while(numDeleters >0 OR numInserters>0 ){
            wait(inserters);
        }
        numInserters=numInserters+1;
    }
    procedure liberar_Inserter(){
        numInserters=numInserters-1;
        signal(inserters);
        if(numSearchers==0 ){
            signal(deleters);
        }
    }
 }
    
process Searchers[i=1..S] {
    Controlador_ListaEnlazada.pedir_Searcher();
    <Realiza búsqueda en la lista>
    Controlador_ListaEnlazada.liberar_Searcher();
}
process Inserters[j=1..I] {
    Controlador_ListaEnlazada.pedir_Inserter();
    <Inserta en la lista>
    Controlador_ListaEnlazada.liberar_Inserter();
}
process Deleters[k=1..D] {
    Controlador_ListaEnlazada.pedir_Deleter();
    <Borra en la lista>
    Controlador_ListaEnlazada.liberar_Deleter()
}

int aviso [1:n]=([n]0), permiso [1:n]=([n]0);
process SC[i = 1 to N] {
    SNC;
    permiso[i] = 1; # Protocolo
    while (aviso[i]==0) skip; # de entrada
    SC;
    aviso[i] = 0; # Protocolo de salida
    SNC;
}
process Coordinador {
    int i = 1;
    while (true) {
        while (permiso[i]==0) i = i mod N +1;
        permiso[i] = 0;
        aviso[i] = 1;
        while (aviso[i]==1) skip;
    }
}

En la P1, sólo se envían 10 mensajes al proceso grano2. En P2 se envían 10000 mensajes.

En P1, el envío de los mensajes se realiza después de largos períodos de ejecución ya que entre cada send se ejecuta una iteración de 10000 unidades de tiempo, esto nos asegura que la comunicación entre los dos procesos es poco frecuente. Dadas dichas características podemos decir, que desde el punto de vista de la granularidad, P1 es de granularidad gruesa ya que la comunicación ente los procesos no es de manera reiterada.

Al tener mayor granularidad disminuye la concurrencia y la sobrecarga de bloqueos.

En P2, el envío de mensajes se realiza en intervalos cortos de tiempo (entre la ejecución de cada send sólo se ejecuta un for de 1 a 10), aumentando considerablemente la comunicación respecto de P1. Por lo tanto, podemos decir que P2 es de granularidad fina, ya que en cada iteración el volumen de comunicación aumenta, por lo tanto la relación cómputo / comunicación disminuye. Al disminuir la granularidad aumenta la concurrencia pero también aumenta la sobrecarga de bloqueos.

c) Cuál de los programas le parece más adecuado para ejecutar sobre una arquitectura de tipo cluster de PCs? Justifique.

La implementación más adecuada para este tipo de arquitecturas es P1, por ser de granularidad gruesa. Al tratarse de una arquitectura con memoria distribuida la comunicación entre los procesos es más costosa ya que cada proceso puede ejecutarse en computadores diferentes, por lo tanto sería más eficiente que la sobrecarga de comunicación sea lo más baja posible, y dicha característica la brinda la granularidad gruesa

Ambos programas realizan la suma de todos los elementos de una matriz pero difieren en la forma de llegar al resultado. P1 Genera le envía los 10000 2 valores a acumula para que este los sume mientras que en P2 Genera solo le envía 10000 valores ya que el mismo se encarga de sumar toda una fila. Es decir, le envía a acumula la suma de todos los elemento de cada fila.

P1 realiza 10000^2 envíos de mensajes (uno por cada elemento de la matriz) mientras que P2 solo realiza 10000 (uno por cada fila de la matriz).

Se puede decir que el proceso P2 es de grano más grueso que el proceso P1 ya que realiza más procesamiento en Genera y esto hace que se necesite un menor número de comunicaciones con Acumula para llegar al resultado.

Las arquitecturas del tipo cluster pueden considerarse arquitecturas de grano grueso ya que poseen muchos procesadores con mucha capacidad de cómputo pero con poca capacidad para la comunicación haciéndolos más apropiados para ejecutar programas de grano grueso que requieren de menos comunicación que capacidad de computo. Por lo tanto, P2 sería más apropiado para ejecutarse sobre este tipo de arquitecturas.

Aquí tienes el contenido de la imagen convertido a texto:

```plaintext
type clase_op = enum(adquirir, liberar);
chan request(int idCliente, claseOp oper, int idUnidad);
chan respuesta[n] (int id_unidad);

Process Administrador_Recurso {
    int disponible = MAXUNIDADES;
    set unidades = valor inicial disponible;
    queue pendientes;
    while (true){
        receive request (IdCliente, oper, id_unidad);
        if (oper == adquirir){
            if (disponible > 0){
                disponible = disponible - 1;
                remove (unidades, id_unidad);
                send respuesta[IdCliente] (id_unidad);
            }
            else insert (pendientes, IdCliente);
        }
        else{
            if (empty (pendientes)){
                disponible = disponible + 1;
                insert (unidades, id_unidad);
            }
            else{
                remove (pendientes, IdCliente);
                send respuesta[IdCliente] (id_unidad);
            }
        }
    } 
    //while
}//process Administrador_Recurso

Process Cliente[i = 1 to n]
{
    int id_unidad;
    send request(i, adquirir, 0);
    receive respuesta[i](id_unidad);
    //Usa la unidad
    send request(i, liberar, id_unidad);
}

No son equivalentes ya que el DO en segmento 1 terminaría para valores de cant (1…10) (-1…-10) mientras que en segmento 2 el if fallaría pero la iteración se seguiría realizando.

Son equivalentes con estas condiciones no hay ningún caso en el que todas las guardas fallen por lo tanto el DO no termina nunca, obteniendo el mismo comportamiento que el while true con el IF.

No son equivalentes ya que el DO termina si cant=0 porque todas las guardas son false.

No son equivalente ya que para cant = 10 o cant=-10 segmento 1 terminaría su ejecución del DO porque todas las guardas serían falsas.

Serian equivalentes ya que se estarían eliminando en segmento 1 los valores puestos en d) que provocarían que el DO terminase.

Estoy de acuerdo con José. Ya que existen secuencias de ejecución en las cuales no funciona correctamente.

Por ejemplo si P1 ejecuta su primera linea y suma cantidad:=cantidad + 1, y corta su ejecución, se ejecuta P2, la condición de cantidad>0 da verdadera pero no existe nada en el buffer y P2 en su primera linea ejecuta elemento_a_sacar := buffer