Semafori. Sincronizzazione di processi e thread (2) Semafori di Dijkstra. Meccanismi di sincronizzazione

Transcript

1 Semafori Sincronizzazione di processi e thread (2) Meccanismi di sincronizzazione Semafori di Dijkstra Inventati nel 1960s Meccanismo concettuale: nessuna implementazione specificata Meccanismo di sincronizzazione di base nei sistemi operativi

2 Definizione di Dijkstra Una variabile intera non negativa che può essere cambiata o testata da due funzioni atomiche - verhoog (incrementa) = up = signal =post V(s): [s = s + 1] - prolaag (probeer te verlagen = prova a decrementare) = down = wait P(s): [while(s == 0) {wait; s = s - 1] Tipi di Semafori Binari: Valori 0 e 1 Usati per la mutual exclusion (mutex) Possono essere utilizzati per il signaling Semafori contatore (Counting Semaphores): Prendono un qualsiasi valore >0 Contano risorse e bloccano i resource consumers quando le risorse sono esaurite Implementare i Semafori Due modalità distinte: busy waiting (spinlock): la CPU controlla attivamente il verificarsi della condizione di accesso alla sezione critica scalabile, veloce CPU-intensive adatto per attese brevi (accesso a memoria) sleep (mutex,semaforo): il processo viene messo in attesa (sleep) che si verifichi la condizione di accesso alla sezione critica più lento adatto per attese lunghe (I/O) Implementazione dei semafori con busy wait (1) typedef struct { int valore; semaforo; void Wait(semaforo S) { S.valore--; while (S.valore < 0) { void Signal(semaforo S) { S.valore++;

3 Implementazione dei semafori con busy wait e interrupts (1) typedef struct { int valore; semaforo; void Wait(semaforo S) { disableinterrupts(); S.valore--; while (S.valore < 0) { enableinterrupts(); disableinterrupts(); enableinterrupts(); void Signal(semaforo S) { disableinterrupts(); S.valore++; enableinterrupts(); Implementazione dei semafori con sleep (2) typedef struct { int valore; struct processo *p; semaforo; void Wait(semaforo S) { S.valore--; if (S.valore < 0) { <accoda processo a S.p>; block(); void Signal(semaforo S) { S.valore++; if (S.valore <= 0) { <estrai un processo p da S.p>; wakeup(p); puntatore alla lista dei processi in attesa di entrare nella sezione critica mette il processo in stato di attesa KERNEL mette il processo in stato di pronto Implementazione dei semafori: commenti Un esempio reale: Semafori in MANTIS OS Le funzioni block() e wakeup() devono essere fornite dal SO Il criterio di estrazione usato nella wakeup() è, generalmente, FIFO, ma può non essere il solo L'esecuzione di wait() e signal() è atomica wait() e signal() considerate come vere e proprie sezioni critiche void mos_sem_wait(mos_sem_t *s) { handle_t int_handle; int_handle = mos_disable_ints(); s->val--; // If no resources are available then we wait in the queue if(s->val < 0) { mos_thread_t *id; id = mos_thread_current(); mos_tlist_add(&s->q, id); mos_thread_suspend_noints(int_handle); else mos_enable_ints(int_handle); P(s) void mos_sem_post(mos_sem_t *s) { handle_t int_handle; mos_thread_t *thread; int_handle = mos_disable_ints(); // Post a unit and wake-up the next waiting thread s->val++; if((thread = mos_tlist_remove(&s->q)) = NULL) { mos_thread_resume_noints_nodispatch(thread, int_handle); mos_enable_ints(int_handle); else { mos_enable_ints(int_handle); V(s)

4 Sezione critica con semafori Signaling con Semafori: Barriere semaphore_t mutex = 1; int var_condivisa; void worker() { while(1) { Wait(mutex); var_condivisa ++; Signal(mutex); Sincronizzazione di più processi Attendono alla barriera finchè tutti arrivano Poi proseguono... A A A B B B C C C D D D A B C D Processi che arrivano alla barriera B e D alla barriera Tutti alla barriera Barriera rilascia i processi Operating Systems and 14Distributed Systems Signaling con Semafori: Barriere Usa un binary semaphore per segnalare un evento Un thread attende un evento con Wait Un thread segnala l evento con Signal Questo crea una barriera fra i due Thread Signaling con Semafori: sincr. Driver/Controller Driver: segnala il controller con Signal(busy), e attende il completamento dell operazione con Wait(done) Controller: attende richieste con Wait(busy), e segnala il completamento con Signal(done) Thread #1 Thread #2 Device driver Controller Signal(ready1); Wait(ready2); Signal(ready2); Wait(ready1); Variabili Globali semaphore ready1 = 0; semaphore ready2 = 0; Signal(busy); Wait(done); Wait(busy); Signal(done); Variabili Globali semaphore busy = 0; semaphore done = 0;

5 Signaling con Semafori: serializzazione Sequenza di operazioni Semafori POSIX: con nome Due forme: named semaphores unnamed semaphores. Named semaphore identificato da un nome. Due processi lo possono utilizzare passando uno stesso nome a sem_open(). crea o apre un named semaphore esistente. Dopo l apertura: sem_post() and sem_wait(). Chiusura: sem_close() Distruzione( quando i processi sono terminati) sem_unlink() I named semaphores POSIX hanno persistenza nel kernel: se non sono rimossi da sem_unlink(), un semaforo esiste fino allo shut down del sistema. Semafori POSIX: anonimi Due forme: named semaphores unnamed semaphores. Un unnamed semaphore è anonimo. Collocato in una regione di memoria condivisa fra più threads ( thread-shared semaphore) o più processi (process-shared semaphore). Thread-shared semaphore: esempio, una variabile globale. Process-shared semaphore: esempio shared memory region (e.g., in System V shared memory segment creato con semget(), oppure un shared memory object POSIX ottenuto mediante shm_open()). Prima di usarlo: sem_init(). Dopo l apertura: sem_post() and sem_wait(). Distruzione: sem_destroy(). Prototipi definiti in semaphore.h. Dichiarazione: Inizializzazione: Semafori POSIX sem_t sem_name; int sem_init(sem_t *sem, int pshared, unsigned int value); sem puntatore al semaforo pshared =1 se shared con processi fork()ed. value valore iniziale del semaforo (1 per sem binari) Esempio: sem_init(&sem_name, 0, 10);

6 Semafori POSIX Attesa su semaforo: int sem_wait(sem_t *sem); esempio: sem_wait(&sem_name); Se il valore è <0, il processo si blocca; un processo bloccato si risveglia (wake up) quando un altro processo segnala con sem_post. Per segnalare (incrementare il valore): int sem_post(sem_t *sem); Esempio: sem_post(&sem_name); Semafori POSIX Interrogare il valore del semaforo int sem_getvalue(sem_t *sem, int *valp); il valore viene scritto all indirizzo puntato da valp Esempio: int value; sem_getvalue(&sem_name, &value); printf("il valore e %d\n", value); Distruzione semaforo: int sem_destroy(sem_t *sem); funzione se nessun thread è bloccato sul semaforo Esempio: sem_destroy(&sem_name); Semafori POSIX: esempio #define NITER int count = 0; sem_t mymutex; //Declare the semaphore global (outside of any function) void * ThreadAdd(void *); //function executed by threads int main(int argc, char * argv[]){ pthread_t tid1, tid2; //Initialize the unnamed semaphore in the main function: initial value is set to 1. // Note the second argument: passing zero denotes that the semaphore is shared between threads (and // not processes). sem_init(&mymutex, 0, 1); pthread_create(&tid1, NULL, ThreadAdd, NULL); pthread_create(&tid2, NULL, ThreadAdd, NULL); pthread_join(tid1, NULL); /* wait for the thread 1 to finish */ pthread_join(tid2, NULL); /* wait for the thread 2 to finish */ if (count < 2 * NITER) printf("\n BOOM count is [%d], should be %d\n", count, 2*NITER); else printf("\n OK count is [%d]\n", count); // destroys the semaphore; no threads should be waiting on the semaphore if its destruction is to succeed sem_destroy(&mymutex); pthread_exit(null); void * ThreadAdd(void * a){ int i, tmp; int value; for(i = 0; i < NITER; i++){ //entering the critical section: wait on semaphore sem_wait(&mymutex); tmp = count; /* copy the global count locally */ tmp = tmp+1; /* increment the local copy */ count = tmp; /* store the local value into the global count */ //exiting the critical section: sem_post(&mymutex); Semafori POSIX: esempio Compile & run p_thraddsem.c Oppure provare (per MacOS) il codice platform independent in p_thraddsem2.c

7 Signaling con Semafori: Barriere Compile & run p_sembarr.c macbook-di-giuseppeboccignone:lez15_ex2 Bebo$./p_sembarr Thread 1 qui, prima della barriera. Thread 2 qui, prima della barriera Thread 2 dopo la barriera. Thread 1 dopo la barriera. main() reporting: tutti i 2 thread terminati Il problema del bounded buffer o del produttore/consumatore Producer Empty Pool Full Pool Consumer Il problema del bounded buffer o del produttore/consumatore Produttore: mette items in un bounded buffer condiviso Consumatore: preleva items dal bounded buffer If buffer==vuoto il consumatore non può prelevare If buffer== PIENO il produttore non può inserire Operating Systems and 27Distributed Systems Il problema del bounded buffer o del produttore/consumatore Variabili condivise const int n; typedef Item; Item buffer[n]; int in = 0, out = 0, counter = 0; Produttore Item pitm; while (1) { produce un item in pitm while (counter == n) ; buffer[in] = pitm; in = (in+1) % n; counter ++; Operating Systems and 28Distributed Systems Istruzioni atomiche: Counter ++; Counter --; Consumatore Item citm; while (1) { while (counter == 0) ; citm = buffer[out]; out = (out+1) % n; counter --; consume l item in citm

8 Produttore/consumatore con semafori Produttore/consumatore con semafori #define BSIZE 4 #define NUMITEMS 30 #define NUM_THREADS 2 pthread_t tid[num_threads]; //number of slots in the buffer //max number of items // array of thread IDs typedef struct { char buf[bsize]; int occupied; int nextin, nextout; #ifdef APPLE semaphore_t mutex ;//control access to critical region semaphore_t more ; //counts full buffer slots semaphore_t less ; //counts empty buffer slots #else sem_t mutex;//control access to critical region sem_t more; //counts full buffer slots sem_t less; //counts empty buffer slots #endif buffer_t; buffer_t buffer; Produttore/consumatore con semafori Produttore/consumatore con semafori int main( int argc, char *argv[] ) { int i; _sem_create(&(buffer.mutex), 1); _sem_create(&(buffer.more), 0); _sem_create(&(buffer.less), BSIZE); pthread_create(&tid[1], NULL, consumer, NULL); pthread_create(&tid[0], NULL, producer, NULL); for ( i = 0; i < NUM_THREADS; i++) pthread_join(tid[i], NULL); printf("\nmain() reporting that all %d threads have terminated\n", i); _sem_destroy(&(buffer.mutex)); _sem_destroy(&(buffer.more)); _sem_destroy(&(buffer.less)); return 0; /* main */ void *producer(void * parm) { char item[numitems]="e UN MONDO PICCOLO, DOPO TUTTO."; // items to be put in buffer int i; printf("producer started.\n"); for(i=0;i<numitems;i++) { // produce an item, one character from item[] if (item[i] == '\0') break; // Quit if at end of string. if (buffer.occupied >= BSIZE) printf("producer waiting.\n"); _sem_wait(&(buffer.less)); //decrement empty count _sem_wait(&(buffer.mutex)); //enter critical region printf("producer executing.\n"); buffer.buf[buffer.nextin++] = item[i];//put new item in buffer buffer.nextin %= BSIZE; buffer.occupied++; //items in buffer _sem_signal(&(buffer.mutex)); //leave critical region _sem_signal(&(buffer.more)); //signals the consumer and increments full count printf("producer exiting.\n"); pthread_exit(0); 31 32

9 Produttore/consumatore con semafori void *consumer(void * parm) { char item; int i; printf("consumer started.\n"); for(i=0;i<numitems;i++){ // consume an item, one character from buffer if (buffer.occupied <= 0) printf("consumer waiting.\n"); _sem_wait(&(buffer.more)); //decrement full count _sem_wait(&(buffer.mutex)); //enter critical region printf("consumer executing.\n"); item = buffer.buf[buffer.nextout++];//take item from buffer buffer.nextout %= BSIZE; buffer.occupied--; _sem_signal(&(buffer.mutex)); //leave critical region _sem_signal(&(buffer.less)); //signals the producer and increments empty count printf("%c\n",item); //prints the item printf("consumer exiting.\n"); pthread_exit(0); Produttore - consumatore Compile & run p_boundsem.c 33 Lettori e scrittori Lettori e scrittori s s Shared Resource

10 Lettori e scrittori Lettori e scrittori Shared Resource Shared Resource Lettori e scrittori Compile & run p_rwexsem.c 39