Sincronización

Question 1

Explicar el concepto de semáforo.

Answer 1

Un semáforo es un mecanismo de sincronización que permite que hasta N entidades accedan al mismo recurso a la vez.

Por ejemplo, el recurso puede ser un chat y el semáforo permite que haya hasta 5 integrantes a la vez en el grupo.

Question 2

Implementar en pseudo-código un semáforo.

Answer 2

Cortesía de Lucas:

pub struct Semaphore{
let mutex: Mutex<usize>,
let condvar: Condvar,
}</usize>

impl Semaphore{
pub fn new(inital_count){
Semaphore{
mutex = Mutex::new(inital_count);
condvar= Condvar::new();
}
}

pub fn wait(&self){
    let lock = self.mutex.lock.unwrap();
    self.condvar.wait_while(lock, |lock| *lock==0 )
    *lock -=1;
}

pub fn signal(&self){
    let lock = self.mutex.lock.unwrap();
    *lock +=1;
    self.condvar.notify_one();
}

Question 3

Explicar el concepto de barrera.

Answer 3

Una barrera es un mecanismo de sincronización que sirve para asegurar que todos los hilos correspondientes llegan a cierto punto del código (donde se encuentra la barrera) antes de avanzar.

Generalmente se utiliza para coordinar procesos, o sincronización de fases, donde se tienen etapas del código y se necesita que todos los hilos completen una etapa antes de que cualquiera pueda pasar a la siguiente.

Question 4

Implementar en pseudo-código una barrera.

Answer 4

Cortesía de Lucas

pub struct Barrera{
num_threads: usize
lock: Mutex<BarrierState>
condvar: Condvar
}</BarrierState>

pub struct BarrierState{
count: usize
generation_id: usize //para que la barrera se pueda reutilizar
}

impl Barrier{
pub fn new(n: usize) -> Barrier{
Barrier{
num_threads = n;
lock: Mutex::new(BarrierState::new(generation_id: 0, count: 0));
condvar: Condvar::new;
}
}
pub fn wait(&self) -> Result{
let mut lock = self.lock.lock().unwrap();
let local_gen = lock.generation_id;
lock.count += 1;
if lock.count < self.num_threads{ //todavía faltan hilos por llegar
self.condvar.wait_while(lock, |state| local_gen == state.generation_id ).unwrap();
Result(false);
} else { //ya llegaron todos los hilos
lock.count = 0; //reiniciamos la cuenta
lock.generation_id.wrapping_add(1); //aumentamos la generación
self.condvar.notify_all();
Result(true);
}
}
}

Question 5

Qué es una conditional variable?

Answer 5

Una conditional variable es un tipo de variable que sirve para sincronizar y coordinar procesos. Se utiliza cuando se necesita que un hilo se quede esperando a que cierta condición se vuelva verdadera, y que en ese momento, se despierte y actúe.

Estas variables no almacenan valores en sí, sino que se utilizan para señalar eventos o condiciones específicas.

Question 6

Explicar el concepto de monitor. Es posible crear un monitor genérico?

Answer 6

Un monitor es una herramienta de más alto nivel que un semáforo o una barrera, y le permite a los hilos tener exclusión mutua de una sección crítica y de un estado interno que se busca compartir.

La idea es que el monitor “envuelva” al estado interno que protege, y que coordine el acceso al mismo. El propio monitor manejará todo lo relacionado a la concurrencia y sincronización del estado interno, por lo que el que utilice el monitor no tendrá que preocuparse por locks ni race conditions.

No, no es posible crear un monitor genérico (hasta donde sé, al menos). Para que un monitor funcione, no sólo se envuelve el estado interno, sino que además se provee una interfaz propia de la entidad para que el resto del programa interactúe con él.

Question 7

Comparar los método notify_one y notify_all. Cuál conviene usar? Por qué?

Answer 7

Cortesía de Lucas:

• notify_one se utiliza cuando querés despertar a un solo sleeper, elegido de manera aleatoria.
• notify_all se utiliza cuando querés despertar a todo el conjunto de sleepers

En general, se recomienda utilizar notify_one antes que notify_all, ya que en general que todos los sleepers se despierten resulta en un desperdicio de recursos. Sólo usar notify_all si es seguro que necesitás a todos los sleepers.

Question 8

Cuál es la diferencia entre mutex y semáforo?

Answer 8

Un mutex es un mecanismo de sincronización que permite que una entidad a la vez revise la variable que se está resguardando.
Un semáforo permite que hasta N entidades diferentes revisen a la vez la variable.

Un mutex es un caso particular del semáforo.