C - semafori privati vs mutex & condition variables (userspace/kernel) - dubbio

[markzzz]

salve,

ho iniziato da poco a studiare la programmazione concorrente, e ovviamente mi son inbattuto in queste primitive.

devo far luce su queste problematiche...

1 - semaforo :
wait : if counter==0, thread rimosso dalla ready e inserito nella blocked queue; else if counter>0 counter--
post : if counter==0, thread rimosso dalla blocked e inserito nella ready queue; else counter++

ma blocked/ready queue sono le code dei processi a livello sistema operativo? oppure sono delle struttura dati (implementate dai semafori) che si occupano di accodarli e di richiamarli quando il contatore diventa a 0?

2 - mutex & condition variables :
quì non ci sono contatori. se un processo deve aspettare finisce in in una blocked queued.
stessa domanda di sopra... è la coda dei processi del sistema operativo o un'altra struttura? poi la logica di come venga risvegliato un processo dentro questa coda, non essendoci contatori, è un altro mistero... (ma ci saran dei costrutti specifici)

3 - semafori livello kernel :
quando un processo livello kernel deve mettersi in attesa, bisogna impostare lo stato su TASK_INTERRUPTIBLE e schedularlo (per una migliore efficenza) : ma perchè si fà questo a livello kernel e a livello userspace non bisogna farlo?

spero si possa far luce... cordiali saluti

[Daniele23]

Ciao ti faccio vedere un esempio in java...

Codice: Seleziona tutto

public class Semaforo {

	private int cont;

	public Semaforo(int startingCont) {
		cont = startingCont;
	}

	public void down() {
		synchronized (this) {
			while (cont <= 0) { // Se il semaforo è <=0 devo aspettare
				try {
					wait();
				} catch (InterruptedException e) {

				}
			}
			cont--; // Decremento il semaforo
		}
	}

	public void up() {
		synchronized (this) {
			cont++;
			// notifico a un processo in attesa di svegliarsi
			if (cont == 1) {
				notify();
			}
		}
	}

}

il mio metodo down() sarebbe il tuo wait() e il mio up() sarebbe il tuo post.
Il concetto è questo ogni Thread controlla il semaforo se <=0 si addormenta fino a quando qualche altro thread con una up() su quel semaforo lo risveglia.
Riguardo a questo

oppure sono delle struttura dati (implementate dai semafori)

non credo...
Invece

2 - mutex & condition variables :
quì non ci sono contatori. se un processo deve aspettare finisce in in una blocked queued.
stessa domanda di sopra... è la coda dei processi del sistema operativo o un'altra struttura? poi la logica di come venga risvegliato un processo dentro questa coda, non essendoci contatori, è un altro mistero... (ma ci saran dei costrutti specifici)

I mutex non sono altro che semafori anche loro per garantire la mutua esclusione, se ad esempio molti processi lavorano su dei contatori comuni è probabile che sia meglio proteggerli  con un mutex...
Se guardi la mia classe semaforo capirai come si risvegliano i processi se guardi nel metodo up() che sarebbe il tuo post() vedrai che c'è  una chiamata a notify() che appunto risveglia i processi addormentati.

Riguardo al punto 3 non so :-\

ciao