## Ejercicio 3
*Dado un numero N verifique cuantas veces aparece ese número en un arreglo de longitud M. Realice el algoritmo en forma concurrente utilizando <> y <await B; S>. Escriba las condiciones que considere necesarias.*

```
int a[M]; int x; int count = 0; int s=M;
# 1 proceso para cada valor del arreglo, osea M procesos. No vale la pena, ya que son acciones atomicas entonces 1 solo modifica x al mismo tiempo no?
process A [ i=1 to M ] {
        <x = a[i];s-->
}
process B {
        while(s>0){
                <await(x==N); count=count+1;
        }
}
deadlock en caso de que ninguno de los procesos asigne un N a x ??
```

```
# MAL?, se suma una sola vez no?
int a[M]; int count=0; int x;
co
for [i=1 to M] {
        if(x==N) <count++>
}
oc
```

```
# Similar al primero, pero con 1 proceso solo para toda la iteracion
int a[M]; int count = 0; int x; int s=M;
process A {
        for [i=1 to M]{
                <x=a[i];s--;>
        }

}
process B {
        while(s>0){
                <await(x==N) count=count+1;>
        }
}
```

```
segun la diapositiva puedo hacer algo asi:
int a[M]; int count = 0;
bool lock=false;
process A[i=1..M]{
        if(a[i]==N)
                <await(not lock) lock=true;>
                 count++; # Aca yo creo que no hace falta hacerla atomica a la suma de count no?
                lock=false;
}

```

```
process A[i=1..M]{
        if(a[i]==N)
                <count++>;
}
```

## Ejercicio 4
*Resuelva el problema de acceso a sección crítica usando un proceso coordinador. En este caso, cuando un proceso SC[i] quiere entrar a su sección crítica le avisa al coordinador, y espera a que éste le dé permiso. Al terminar de ejecutar su sección crítica, el proceso SC[i] le avisa al coordinador. Desarrolle una solución de grano fino usando sólo variables compartidas.*

```
# todos falsos todooooos
bool requests[1..n];
bool permissions[1..n];


process worker[i=1..n]{
        while(true){
                requests[i] = true;
                while(!permissions[i]){
                        skip
                }
                SC[i]
                permissions[i]=false;
        }

}

process coordinator {
        while(true){
                for(i=1..n){
                        if(!requests[i]) skip;
                        permissions[i]=true
                        while(permissions[i]){}
                        requests[i]=false;
                }
        }
}
```