Sistemi Operativi Laurea in Ingegneria Informatica Sapienza Universita di Roma Docente: Francesco Quaglia
|
|
- Emilia Mantovani
- 5 anni fa
- Visualizzazioni
Transcript
1 Sistemi Operativi Laurea in Ingegneria Informatica Sapienza Universita di Roma Docente: Francesco Quaglia Concorrenza, comunicazione e sincronizzazione 1. Memoria condivisa e sezioni critiche 2. Approcci per la sincronizzazione 3. Semafori 4. IPC in sistemi attuali (Windows/UNIX)
2 IPC (Inter Process Communication) IPC riguarda tutti quei servizi di sistema operativo atti a far si che thread di uno stesso processo o di processi distinti possano accedere a risorse condivise Le risorse sono gestite dalla stessa istanza di sistema operativo IPC serve anche per il supporto allo scambio di informazioni tramite servizi (in taluni/molti casi) alternativi a quelli offerti dal VFS
3 Elementi di condivisione/comunicazione NOTI Condivisione dello spazio di indirizzamento logico tra i thread di uno stesso processo Condivisione del contenuto di oggetti di I/O (VFS style) Comunicazione tramite oggetti di I/O (VFS style) NUOVI Condivisione dello spazio di indirizzamento tra thread di processi distinti (memoria condivisa) Comunicazione tramite scambio di messaggi (non necessariamente legato ad API del VFS)
4 Memoria condivisa Spazio ind. Proc. A Spazio ind. Proc. B Regione condivisa la regione condivisa e costituita da una sequenza di bytes che possono essere letti e/o scritti da entrambi i processi dal punto di vista del sistema operativo la regione condivisa e equivalente ad una qualsiasi regione non condivisa dello spazio di indirizzamento il contenuto della memoria condivisa dipende dalla sequenza di accessi in scrittura da parte dei processi la massima porzione della memoria condivisa che puo essere letta/scritta da un processo in modo atomico dipende dalle istruzioni di linguaggio macchina (relazioni con la taglia del BUS dati)
5 Realizzazione Process A Address X The special case is when Table A Table B Page table A Page table B Process B Address y Logical memory segment Real RAM storage Logical memory segment Not necessarily contiguous (backed on swap storage)
6 Produttore/consumatore tramite memoria condivisa counter buffer[0] buffer[n-1] PRODUTTORE Repeat <produce X> while counter = N do no-op; buffer[in] := X; in := (in+1)mod(n) counter := counter + 1; until false CONSUMATORE Repeat while counter = 0 do no-op; Y := buffer[out]; out := (out+1)mod(n) counter := counter - 1; <consume Y> until false
7 Sezioni critiche counter := counter + 1 counter := counter - 1 Reg1:= counter Reg1:= Reg1 + 1 counter := Reg1 Reg2:= counter Reg2:= Reg2-1 counter := Reg2 interleaving Reg1:= counter Reg1:= Reg1 + 1 Reg2:= counter Reg2:= Reg2-1 counter := Reg2 counter := Reg1 Una sezione critica e una porzione di traccia ove un processo/thread puo leggere/scrivere dati condivisi con altri processi/thread la correttezza del risultato dipende dall interleaving delle tracce di esecuzione Risoluzione del problema della sezione critica permettere l esecuzione della porzione di traccia relativa alla sezione critica come se fosse un azione atomica
8 Vincoli per il problema della sezione critica Mutua esclusione quando un thread accede alla sezione critica nessun altro thread puo eseguire nella stessa sezione critica Progresso un thread che lo chiede deve essere ammesso alla sezione critica senza ritardi in caso in cui nessun altro thread si trovi nella sezione critica Attesa limitata un thread che lo chiede deve essere ammesso ad eseguire la sezione critica in un tempo limitato (non ci devono essere stalli o starvation) Approcci risolutivi algoritmi di mutua esclusione (gia noti) harware specializzato (parzialmente noti) semafori (parzialmente noti)
9 Stallo (deadlock) di processi Un insieme di processi P1,..., Pn e coinvolto in uno stallo se ognuno dei processi e in attesa (attiva o passiva) di un evento che puo essere causato solo da un altro dei processi dell insieme P1 P3 P2 P4 P1 P3 P5 Genesi di un deadlock P2 P4 P5
10 Algoritmi di mutua esclusione: Dekker var turno: int; Processo X While turno X do no-op; <sezione critica>; turno := Y; Processo Y While turno Y do no-op; <sezione critica>; turno := X; I processi vanno in alternanza stretta nella sezione critica non c e garanzia di progresso la velocita di esecuzione e limitata dal processo piu lento I processi lavorano come coroutine (ovvero routine che si passano mutuamente il controllo), classiche della strutturazione di un singolo processo, ma inadeguate a processi concorrenti
11 Secondo tentativo var flag: array[1,n] of boolean; Processo X Processo Y While flag[y] do no-op; flag[x] := TRUE; <sezione critica>; flag[x] := FALSE; While flag[x] do no-op; flag[y] := TRUE; <sezione critica>; flag[y] := FALSE; I processi non vanno in alternanza stretta nella sezione critica c e garanzia di progresso non c e garanzia di mutua esclusione (problema che diviene evidente nel caso di numero elevato di processi)
12 Terzo tentativo var flag: array[1,n] of boolean; Processo X Processo Y flag[x] := TRUE; While flag[y] do no-op; <sezione critica>; flag[x] := FALSE; flag[y] := TRUE; While flag[x] do no-op; <sezione critica>; flag[y] := FALSE; Possibilita di deadlock, non c e garanzia di attesa limitata Processo X Processo Y
13 Quarto tentativo var flag: array[1,n] of boolean; Processo X flag[x] := TRUE; While flag[y] do { flag[x] := FALSE; <pausa>; flag[x] := TRUE; <sezione critica>; flag[x] := FALSE; Processo Y flag[y] := TRUE; While flag[x] do { flag[y] := FALSE; <pausa>; flag[y] := TRUE; <sezione critica>; flag[y] := FALSE; Possibilita di starvation, non c e garanzia di attesa limitata
14 var choosing: array[1,n] of boolean; number: array[1,n] of int; repeat { Algoritmo del fornaio Basato su assegnazione di numeri per prenotare un turno di accesso alla sezione critica choosing[i] := TRUE; number [i] := <max in array number[] + 1>; choosing[i] := FALSE; for j = 1 to n do { while choosing[j] do no-op; while number[j] 0 and (number [j],j)< (number [i],i) do no-op; <sezione critica>; number[i] := 0; until FALSE
15 Approcci hardware disabilitare le interruzioni (valido nel caso di uniprocessori) istruzioni di basso livello per il test e la manipolazione di informazioni in modo atomico (valido anche per i multiprocessori) function test_and_set(var z: int) : boolean; { if (!z) { z := 1; test_and_set := TRUE; else test_and_set := FALSE; var serratura: int; Processo X While!test_and_set(serratura) do no-op; <sezione critica>; serratura := 0
16 Supporto software Test and set atomico e correntemente supportato tramite specifiche istruzioni macchina L instruzione macchina piu comunemente supportata e la CAS (Compare And Swap) Su architetture x86 tale istruzione corrisponde a CMPXCHG (Compare And Exchange)
17 Semafori: modello di riferimento Un semaforo e una variabile intera con 3 operazioni associate inizializzazione con un valore non negativo una operazione wait che tenta il decremento di una unita ed induce una attesa sul processo che la esegue in caso il valore del semaforo dovesse diventare negativo per effetto del decremento una operazione signal che ne incrementa il valore di una unita e libera dall attesa in attesa un processo che ha eseguito una operazione di wait bloccante Le operazioni devono essere eseguite in modo atomico Semafori binari il valore assunto puo essere solo 1 oppure 0
18 Implementazioni procedure Wait(var s: int); while not CAS(S, 1, 0) do no-op; procedure Signal(var s: int); s := 1; Spin-lock semaphore type semaphore = record value: int; L: list of processes;// or threads end; procedue Wait(var s: semaphore); if s.value 1 < 0 {add process to s.l; block process; s.value = s.value 1; procedure Signal(var s: semaphore); s.value = s.value + 1; {delete a process P from s.l; unblock P; Kernel level semaphore
19 Memoria condivisa in sistemi UNIX int shmget(key_t key, int size, int flag) Descrizione invoca la creazione di un area di memoria condivisibile Parametri 1) key: chiave per identificare la memoria condivisibile in maniera univoca nel sistema (IPC_PRIVATE e un caso speciale) 2) size: taglia in byte della memoria condivisibile 3) flag: specifica della modalita di creazione (IPC_CREAT, IPC_EXCL, definiti negli header file sys/ipc.h e sys/shm.h) e dei permessi di accesso Descrizione identificatore numerico per la memoria in caso di successo (descrittore), -1 in caso di fallimento NOTA Il descrittore indicizza questa volta una struttura unica valida per qualsiasi processo
20 Comandi su una memoria condivisa int shmctl(int ds_shm, int cmd, struct shmid_ds *buff) Descrizione invoca l esecuzione di un comando su una shared memory Parametri 1) ds_shm: descrittore della memoria condivisa su cui si vuole operare 2) cmd: specifica del comando da eseguire (IPC_RMID, IPC_STAT, IPC_SET) 3) buff: puntatore al buffer con eventuali parametri per il comando Descrizione -1 in caso di fallimento IPC_RMID invoca la rimozione della memoria condivisa dal sistema
21 struct shmid_ds { struct ipc_perm shm_perm; /* operation perms */ int shm_segsz; /* size of segment (bytes) */ time_t shm_atime; /* last attach time */ time_t shm_dtime; /* last detach time */ time_t shm_ctime; /* last change time */ unsigned short shm_cpid; /* pid of creator */ unsigned short shm_lpid; /* pid of last operator */ short shm_nattch; /* no. of current attaches */ ; struct ipc_perm { key_t key; ushort uid; /* owner euid and egid */ ushort gid; ushort cuid; /* creator euid and egid */ ushort cgid; ushort mode; /* lower 9 bits of shmflg */ ushort seq; /* sequence number */ ;
22 Attacco/distacco dallo spazio di indirizzamento void *shmat(int ds_shm, void *addr, int flag) Descrizione invoca il collegamento di una memoria condivisa allo spazio di indirizzamento del processo Parametri 1) ds_shm: descrittore della memoria condivisa da collegare 2) *addr: indirizzo preferenziale per il collegamento (NULL come default) 3) flag: modalita di accesso (SHM_R,SHM_W,SHM_RW) Descrizione indirizzo valido per l accesso alla memoria in caso di successo, -1 in caso di fallimento int shmdet(const void *addr) Descrizione invoca lo scollegamento di una memoria condivisa dallo spazio di indirizzamento del processo Parametri *addr: indirizzo della memoria da scollegare Descrizione -1 in caso di fallimento
23 Esempio di applicazione: trasferimento stringhe tra processi #include <sys/types.h> #include <sys/ipc.h> #include <sys/shm.h> #include <stdio.h> #define DISP_ 20 #define Errore_(x) { puts(x); exit(1); char messaggio[256]; void scrittore(int ds) { char *p; p = shmat(ds, 0, SHM_W); if ( p == (char*) -1 ) Errore_("Errore nella chiamata shmat"); puts("digitare le parole da trasferire in memoria condivisa ('quit per terminare):"); do { scanf("%s", messaggio); strncpy(p, messaggio, DISP_); p += DISP_; while( (strcmp(messaggio,"quit")!= 0)); exit(0);
24 void lettore(int ds) { char *p; p = shmat(ds, 0, SHM_R); if ( p == (char*) -1 ) Errore_("Errore nella chiamata shmat"); printf("contenuto memoria condivisa: \n"); while( (strcmp(p,"quit")!= 0)) { printf("%s\n", p); p += DISP_; exit(0); int main(int argc, char *argv[]) { int ds_shm, rit, status; long chiave=30; ds_shm = shmget(chiave, 1024, IPC_CREAT 0666); if ( ds_shm == -1 ) Errore_("Errore nella chiamata shmget"); if (fork()) wait(&status); else scrittore(ds_shm); if (fork()) wait(&status); else lettore(ds_shm); ris = shmctl(id_shm, IPC_RMID, NULL); if ( ris == -1 ) Errore_("Errore nella chiamata shmctl");
25 File mapping NT/2000 HANDLE CreateFileMapping(HANDLE hfile, LPSECURITY_ATTRIBUTES lpattributes, DWORD flprotect, DWORD dwmaximumsizehigh, DWORD dwmaximumsizelow, LPCTSTR lpname) Descrizione invoca il mapping di un file in memoria Restituzione handle al mapping del file
26 hfile: handle ad un file aperto lpattributes: puntatore a una struttura SECURITY_ATTRIBUTES flprotect: modalità di accesso al mapping del file (es. PAGE_READWRITE) dwmaximumsizehigh: dimensione massima del mapping del file (32 bit piu significativi) dwmaximumsizelow: dimensione massima del mapping del file (32 bit meno significativi) lpname: nome del mapping Parametri
27 Apertura di un file mapping HANDLE OpenFileMapping(DWORD dwdesiredaccess, BOOL binherithandle, LPCTSTR lpname) Descrizione accede a un mapping di file esistente Restituzione handle al mapping del file Parametri dwdesiredaccess: modalità di accesso richiesta al mapping di file binherithandle: specifica se l'handle restituito deve essere ereditato da processi figli lpname: nome del mapping gia esistente
28 Collegamento di file mapping LPVOID MapViewofFile(HANDLE hfilemappingobject, DWORD dwdesiredaccess, DWORD dwfileoffsethigh, DWORD dwfileoffsetlow, SIZE_T dwnumberofbytestomap) Descrizione innesta un mapping di file aperto nello spazio di indirizzamento del processo Restituzione un puntatore all'area di memoria contenente il mapping del file, NULL in caso di fallimento Parametri hfilemappingobject: handle ad un file mapping dwdesiredaccess: modalita di accesso desiderata (es. PAGE_READWRITE) dwfileoffsethigh:punto del file mapping da cui iniziare l'innesto (32 bit piu significativi) dwfileoffsetlow: punto del file mapping da cui iniziare l'innesto (32 bit meno significativi) dwnumberofbytestomap: numero di bytes da innestare nello spazio del processo
29 Scollegamento di file mapping BOOL UnmapViewOfFile(LPCVOID lpbaseaddress) Descrizione distacca un mapping di file aperto dallo spazio di indirizzamento del processo Restituzione 0 in caso di fallimento Parametri lpbaseaddress: puntatore all'inizio di un'area di memoria innestata tramite MapViewofFile()
30 Esempio di applicazione: trasferimento stringhe tra processi #include <windows.h> #include <stdio.h> #define DISP_ 20 #define Errore_(x) { puts(x); ExitProcess(1); char messaggio[256]; void scrittore(handle mapping) { char *p; p = (char *) MapViewOfFile(mapping, FILE_MAP_WRITE, 0, 0, 0); if ( p == NULL ) Errore_("Errore nella chiamata MapViewOfFile"); puts("digitare le parole da trasferire in memoria condivisa ('quit' per terminare):"); do { scanf("%s", messaggio); strncpy(p, messaggio, DISP_); p += DISP_; while( (strcmp(messaggio,"quit")!= 0)); ExitProcess(0); continua
31 void lettore(handle mapping) { char *p; p = (char *)MapViewOfFile(mapping, FILE_MAP_WRITE, 0, 0, 0); if ( p == NULL ) Errore_("Errore nella chiamata MapViewOfFile"); printf("contenuto memoria condivisa: \n"); while( (strcmp(p,"quit")!= 0)) { printf("%s\n", p); p += DISP_; ExitProcess(0); int main(int argc, char *argv[]) { HANDLE mapping; BOOL newprocess; STARTUPINFO si; PROCESS_INFORMATION pi; if (argc==1) { /* Creazione/accesso segmento memoria condivisa */ mapping = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 50000, "my_mapping"); if ( mapping == INVALID_HANDLE_VALUE) Errore_("Errore nella CreateFileMapping"); /* genero il processo scrittore */ memset(&si, 0, sizeof(si)); memset(&pi, 0, sizeof(pi)); si.cb = sizeof(si); continua
32 newprocess = CreateProcess(".\\mapper.exe", ".\\mapper.exe scrittore", NULL, NULL, FALSE, NORMAL_PRIORITY_CLASS, NULL, NULL, &si, &pi); if (newprocess == 0) { printf("errore nella generazione dello scrittore!\n"); ExitProcess(-1); WaitForSingleObject(pi.hProcess, INFINITE); memset(&si, 0, sizeof(si)); /* genero il processo lettore */ memset(&pi, 0, sizeof(pi)); si.cb = sizeof(si); newprocess = CreateProcess(".\\mapper.exe", ".\\mapper.exe lettore", NULL, NULL, FALSE, NORMAL_PRIORITY_CLASS, NULL, NULL, &si, &pi); if (newprocess == 0) {printf("errore nella generazione dello scrittore!\n"); ExitProcess(-1); WaitForSingleObject(pi.hProcess, INFINITE); else if (argc == 2 && strcmp(argv[1], "scrittore") == 0){ mapping = OpenFileMapping(FILE_MAP_WRITE, FALSE, "my_mapping"); /* Apro il file mapping */ if (mapping == INVALID_HANDLE_VALUE) {printf("errore nell'aperura del mapping!\n"); ExitProcess(-1) scrittore(mapping); /* chiamo lo scrittore*/ else if (argc == 2 && strcmp(argv[1], "lettore") == 0){ mapping = OpenFileMapping(FILE_MAP_WRITE, FALSE, "my_mapping"); /* Apro il file mapping */ if (mapping == INVALID_HANDLE_VALUE) {printf("errore nell'aperura del mapping!\n"); ExitProcess(-1); lettore(mapping); /* chiamo il lettore */ return(0);
33 Semafori in sistemi UNIX (System V) int semget(key_t key, int size, int flag) Descrizione invoca la creazione di unsemaforo Parametri 1) key: chiave per identificare il semaforo in maniera univoca nel sistema (IPC_PRIVATE e un caso speciale) 2) size: numero di elementi del semaforo 3) flag: specifica della modalita di creazione (IPC_CREAT, IPC_EXCL, definiti negli header file sys/ipc.h e sys/shm.h) e dei permessi di accesso Descrizione identificatore numerico per il semaforo in caso di successo (descrittore), -1 in caso di fallimento NOTA Il descrittore indicizza questa volta una struttura unica valida per qualsiasi processo
34 Comandi su un semaforo int semctl(int ds_sem, int sem_num, int cmd, union semun arg) Descrizione invoca l esecuzione di un comando su un semaforo Parametri 1) ds_sem: descrittore del semaforo su cui si vuole operare 2) sem_num: indice dell elemento del semaforo su cui si vuole operare 3) cmd: specifica del comando da eseguire (IPC_RMID, IPC_STAT, IPC_SET, GETALL, SETALL, GETVAL, SETVAL) 4) arg: puntatore al buffer con eventuali parametri per il comando Descrizione -1 in caso di fallimento union semuu { int val; /* usato se cmd == SETVAL */ struct semid_ds *buf /* usato per IPC_STAT e IPC_SET */ ushort *array; /* usato se cmd == GETALL o SETALL */ ;
35 Operazioni semaforiche int semop(int ds_sem, struct sembuf oper[], int number) Descrizione invoca l esecuzione di un comando su una coda di messaggi Parametri 1) ds_sem: descrittore del semaforo su cui si vuole operare 2) oper: indirizzo dell array contenente la specifica delle operazioni da eseguire 3) number: numero di argomenti validi nell array puntato da oper Descrizione -1 in caso di fallimento struct sembuf { ushort sem_num; short sem_op; /* 0=sincronzzazione sullo 0 n=incremento di n - -n=decremento di n */ short sem_flg; /* IPC_NOWAIT SEM_UNDO */ ; Un decremento di N su un semaforo dal valore minore di N provoca blocco del processo chiamante a meno della specifica di IPC_NOWAIT SEM_UNDO revoca l operazione in caso di exit del processo
36 Per poter annullare operazioni semaforiche, il sistema operativo mantiene una struttura sem_undo in cui sono registrate tali operazioni per ogni processo Il valore di tale struttura non viene ereditato da in processo figlio generato tramite fork() Il valore della struttura viene mantenuto in caso di sostituzione di codice tramite exec()
37 Trasferimento di stringhe con sincronizzazione esplicita #include <sys/types.h> #include <sys/ipc.h> #include <sys/shm.h> #include <sys/sem.h> #include <stdio.h> #define DISP_ 20 #define Errore_(x) { puts(x); exit(1); char messaggio[256]; void produttore(int id, int sem_id) { char *p; int ret; struct sembuf oper; p = shmat(id, 0, SHM_W); if ( p == (char*) -1 ) Errore_("Errore nella chiamata shmat"); puts("digitare le parole da trasferire (quit per terminare):"); do { scanf("%s", messaggio); strncpy(p, messaggio, DISP_); p += DISP_; while( (strcmp(messaggio,"quit")!= 0)); oper.sem_num = 0; oper.sem_op = -1; oper.sem_flg = 0; ret = semop(sem_id, &oper, 1); if ( ret == -1 ) Errore_("Errore nella chiamata semop"); exit(0); continua
38 void consumatore(int id, int sem_id) { char *p; int ret; struct sembuf oper; p = shmat(id, 0, SHM_R); if ( p == (char*) -1 ) Errore_("Errore nella chiamata shmat"); oper.sem_num = 0; oper.sem_op = 0; oper.sem_flg = 0; ret = semop(sem_id, &oper, 1); if ( ret == -1 ) Errore_("Errore nella chiamata semop"); puts("contenuto memoria condivisa:"); while( (strcmp(p,"quit")!= 0)){ printf("%s\n", p); p += DISP_; exit(0); continua
39 int main(int argc, char *argv[]) { long id_shm, id_sem; int ret, status; long chiave_shm=30, chiave_sem = 50; id_shm = shmget(chiave_shm, 1024, IPC_CREAT 0666); if ( id_shm == -1 ) Errore_("Errore nella chiamata shmget"); id_sem = semget(chiave_sem, 1, IPC_CREAT IPC_EXCL 0666); if ( id_sem == -1 ) Errore_("Errore nella chiamata semget"); ret = semctl(id_sem, 0, SETVAL, 1); if ( ret == -1 ) Errore_("Errore nella chiamata semctl"); if ( fork()!=0 ){ if ( fork()!=0 ){ wait(&status); wait(&status); else consumatore(id_shm, id_sem); else produttore(id_shm, id_sem); ret = shmctl(id_shm, IPC_RMID, NULL); if ( ret == -1 ) Errore_("Errore nella chiamata shmctl"); ret = semctl(id_sem, 0, IPC_RMID, 1); if ( ret == -1 ) Errore_("Errore nella chiamata semctl");
40 UNIX: librerie semaforiche e comandi POSIX current sem_t sem_name; sem_t *sem_open(const char *name, int oflag) int sem_init(sem_t *sem, int pshared, unsigned int value); sem_wait(&sem_name); sem_post(&sem_name); sem_getvalue(sem_t *sem, int *valp); POSIX pthread spinlocks spinlock_t lock; spin_lock(&slock); spin_unlock(&lock); SHELL commands ipcs -- ipcrm
41 Mutex NT/2000 Sono in pratica simili a semafori binari, ovvero dei semplici meccanismi per la mutua esclusione HANDLE CreateMutex(LPSECURITY_ATTRIBUTES lpmutexattributes, BOOL binitialowner, LPCTSTR lpname) Descrizione invoca la creazione di un mutex Restituzione handle al mutex in caso di successo, NULL in caso di fallimento Parametri lpmutexattributes: puntatore a una struttura SECURITY_ATTRIBUTES binitialowner: indicazione del processo chiamante come possessore del mutex lpname: nome del mutex
42 Apertura di un mutex HANDLE OpenMutex(DWORD dwdesiredaccess, BOOL binherithandle, LPCTSTR lpname) Descrizione invoca l apertura di un mutex Restituzione handle al mutex in caso di successo, NULL in caso di fallimento Parametri dwdesiredaccess: accessi richiesti al mutex bnherithandle: specifica se l'handle e ereditabile lpname: nome del mutex
43 Operazioni su un mutex Accesso al mutex DWORD WaitForSingleObject(HANDLE hhandle, DWORD dwmilliseconds) Rilascio del mutex BOOL ReleaseMutex(HANDLE hmutex) 0 in caso di fallimento Un solo processo (o thread) viene eventualmente risvegliato per effetto del rilascio del mutex
44 Semafori NT/2000 HANDLE CreateSemaphore(LPSECURITY_ATTRIBUTES lpsemaphoreattributes, LONG linitialcount, LONG lmaximumcount, LPCTSTR lpname) Descrizione invoca la creazione di un semaforo Restituzione handle al semaforo in caso di successo, NULL in caso di fallimento Parametri lpsemaphoreattributes: puntatore a una struttura SECURITY_ATTRIBUTES linitialcount: valore iniziale del semaforo lmaximumcount: massimo valore che il semaforo puo assumere lpname: nome del semaforo
45 Apertura ed operazioni su un semaforo HANDLE OpenSemaphore(LDWORD dwdesiredaccess, BOOL binherithandle, LPCTSTR lpname) Accesso al semaforo DWORD WaitForSingleObject(HANDLE hhandle, DWORD dwmilliseconds) Rilascio del semaforo BOOL ReleaseSemaphore(HANDLE hsemaphore, LONG lreleasecount, LPLONG lppreviouscount) Unita di rilascio Puntatore all area di memoria dove scrivere il vecchio valore del semaforo
46
Sistemi Operativi I Corso di Laurea in Ingegneria Informatica Facolta di Ingegneria, Universita La Sapienza Docente: Francesco Quaglia
Sistemi Operativi I Corso di Laurea in Ingegneria Informatica Facolta di Ingegneria, Universita La Sapienza Docente: Francesco Quaglia Memoria condivisa e semafori: 1. Memoria condivisa 2. Sezioni critiche
Sincronizzazione 1. Sezioni critiche 2. Approcci per la sincronizzazione 3. Spinlock, mutex e semafori 4. Supporti in sistemi UNIX/Windows
Sistemi Operativi Laurea in Ingegneria Informatica Universita di Roma Tor Vergata Docente: Francesco Quaglia Sincronizzazione 1. Sezioni critiche 2. Approcci per la sincronizzazione 3. Spinlock, mutex
Laboratorio di Sistemi Operativi Marzo-Giugno 2008 Matricole congrue 0 mod 3
Marzo-Giugno 2008 Matricole congrue 0 mod 3 IPC: Memoria condivisa e Semafori Memoria Condivisa Permette a due o più processi di condividere una zona di memoria È l IPC più veloce perché in questo caso
INTERPROCESS COMMUNICATION 27
INTERPROCESS COMMUNICATION 27 - Le comunicazioni tra processi (IPC, Intreprocess Communication) sono realizzate mediante strutture dati rese disponibili dal kernel. Sono disponibili 3 tipologie di comunicazioni
Sistemi Operativi I Corso di Laurea in Ingegneria Informatica Facolta di Ingegneria, Universita La Sapienza Docente: Francesco Quaglia
Sistemi Operativi I Corso di Laurea in Ingegneria Informatica Facolta di Ingegneria, Universita La Sapienza Docente: Francesco Quaglia Scambio di messaggi: 1. Nozioni preliminari 2. Primitive 3. Indirizzamento
Corso di Programmazione Concorrente. Semafori. Valter Crescenzi
Corso di Programmazione Concorrente Semafori Valter Crescenzi http://crescenzi.inf.uniroma3.it Semafori vs Semafori di Dijkstra Rispetto alla versione presentata astrattamente, le chiamate di sistema Linux/UNIX
Laboratorio di Sistemi Operativi
primavera 2009 System V IPC sono differenti dalle altre forme di IPC sono contatori usati per controllare l accesso a risorse condivise da processi diversi il protocollo per accedere alla risorsa è il
Il sistema operativo LINUX Semafori. Semaforo. Sommario. Sommario. Uso delle pipe. Gestione di semafori tramite pipe. Sistemi operativi Modulo II
Il sistema operativo LINUX Semafori Semaforo Giorgio Di Natale Stefano Di Carlo Politecnico di Torino Dip. Automatica e Informatica Un semaforo è una variabile
Pipes e named pipes: 1. Nozioni preliminari 2. Pipes e named pipes (FIFO) in sistemi UNIX 3. Pipes e named pipes sistemi Windows
Sistemi Operativi II Corso di Laurea in Ingegneria Informatica Facolta di Ingegneria, Universita La Sapienza Docente: Francesco Quaglia Pipes e named pipes: 1. Nozioni preliminari 2. Pipes e named pipes
Corso di Programmazione Concorrente. Memoria Condivisa. Valter Crescenzi
Corso di Programmazione Concorrente Memoria Condivisa Valter Crescenzi http://crescenzi.inf.uniroma3.it Condivisione di Memoria tra Processi I processi possiedono un spazio di memoria privato non accessibile
Corso di Laboratorio di Sistemi Operativi
Corso di Laboratorio di Sistemi Operativi Lezione 6 Alessandro Dal Palù email: alessandro.dalpalu@unipr.it web: www.unipr.it/~dalpalu Interazione tra Processi I processi concorrenti possono interagire
Processi parte IV. Processi parte IV
Processi parte IV Processi parte IV Grafi di precedenza Sincronizzazione dei processi Unix mediante: fork-join cobegin-coend semafori Grafi di precedenza Un grafo di precedenza è un grafo diretto aciclico
Che cos è la memoria condivisa? Programmazione della memoria condivisa (Shared memory)
Programmazione della memoria condivisa (Shared memory) Memoria aggiunta (attached) allo spazio di indirizzamento dei proprietari, un estensione dello spazio di indirizzamento originario I proprietari condividono
Sistemi di Calcolo - Secondo modulo (SC2) Programmazione dei Sistemi di Calcolo Multi-Nodo
www.dis.uniroma1.it/~midlab Sistemi di Calcolo - Secondo modulo (SC2) Programmazione dei Sistemi di Calcolo Multi-Nodo Corso di Laurea in Ingegneria Informatica e Automatica A.A. 2014-2015 Prof. Roberto
Threads: 1. Concetti di base 2. Threads in sistemi operativi attuali (NT/UNIX)
Sistemi Operativi I Corso di Laurea in Ingegneria Informatica Facolta di Ingegneria, Universita La Sapienza Docente: Francesco Quaglia Threads: 1. Concetti di base 2. Threads in sistemi operativi attuali
Problema dei Produttori e dei Consumatori
Problema dei Produttori e dei Consumatori Appartiene alla categoria di problemi nei quali l esecuzione di un processo dipende dall esecuzione di un altro, per cui è necessaria una comunicazione asincrona
Laboratorio di Sistemi Operativi
primavera 2009 System V IPC code di messaggi System V IPC I tre tipi di IPC di System V sono: Code di Messaggi Semafori Memoria Condivisa Identificatori Ogni struttura IPC è individuata tramite un identificatore
Laboratorio di Sistemi Operativi
Laboratorio di Sistemi Operativi LAB5 System call per gestione semafori 2002/2003 Pagani Trentini Slide 1 Agenda Linux strutture pthread_t, sem_t pthread_create, pthread_exit, sem_init, sem_post, sem_wait,
Sistemi Operativi Laurea in Ingegneria Informatica Universita di Roma Tor Vergata Docente: Francesco Quaglia
Sistemi Operativi Laurea in Ingegneria Informatica Universita di Roma Tor Vergata Docente: Francesco Quaglia Gestione della memoria 1. Binding degli indirizzi. Partizionamento statico e dinamico 3. Allocazione
Laboratorio di Sistemi Operativi
Laboratorio di Sistemi Operativi LAB7 System call per gestione memoria 2002/2003 Pagani Trentini Slide 1 Agenda 1.Linux 1.malloc ; calloc ; realloc (ovvero: brk) ; free; 2.shmctl ; shmget ; shmop Windows
CREAZIONE PROCESSI IN UNIX 20
CREAZIONE PROCESSI IN UNIX 20 STRUTTURE DATI PER PROCESSI Un processo puo' essere in escuzione in 2 modi: kernel e utente. Un processo ha almeno 3 regioni: codice, dati e stack Lo stack è allocato dinamicamente.
Segnali. I segnali in Unix sono un meccanismo semplice per inviare degli interrupt software ai processi.
Segnali I segnali in Unix sono un meccanismo semplice per inviare degli interrupt software ai processi. Solitamente sono utilizzati per gestire errori e condizioni anomale, piuttosto che per trasmettere
6. Sincronizzazione dei Processi. Esempio: Produttore- Consumatore con n elementi. Esempio: Produttore- Consumatore con n elementi
1 6. Sincronizzazione dei Processi Importante: l accesso concorrente a dati condivisi può produrre dati inconsistenti processi cooperanti attraverso la condivisione di dati devono agire in modo ordinato,
Laboratorio di Sistemi Operativi
Marzo-Giugno 2008 Matricole congrue 0 mod 3 code di messaggi XSI IPC Code di Messaggi Semafori Memoria Condivisa 2 1 Identificatori Ogni struttura IPC è individuata tramite un identificatore ( intero>0
Corso di Programmazione Concorrente Produttori / Consumatori. Valter Crescenzi
Corso di Programmazione Concorrente Produttori / Consumatori Valter Crescenzi http://crescenzi.inf.uniroma3.it Problema Produttori / Consumatori Alcuni processi produttori devono continuamente inviare
Sistemi Operativi II
Sistemi Operativi II Massimo Bernaschi Istituto per le Applicazioni del Calcolo Mauro Picone Consiglio Nazionale delle Ricerche Viale del Policlinico, 137-00161 Rome - Italy http://www.iac.cnr.it/ e-mail:
Esercitazione: Utilizzo delle Pipe
Esercitazione: Utilizzo delle Pipe Specifica del problema Struttura generale del programma Esempio per Unix Esempio per Windows 1 Esercizio Realizzazione di una semplice shell che sia in grado di accettare
Crea un nuovo processo. Al processo padre ritorna il PID del figlio. Al processo figlio ritorna 0
Crea un nuovo processo. Al processo padre ritorna il PID del figlio. Al processo figlio ritorna 0 Sequenza di operazioni di fork: * alloca una entry nella tabella dei processi * assegna un unico ID al
INTER-PROCESS COMMUNICATION (IPC) SYSTEM (Bach: the Design of the Unix Operating System ; manuale on-line)
INTER-PROCESS COMMUNICATION (IPC) SYSTEM (Bach: the Design of the Unix Operating System ; manuale on-line) - Memoria Condivisa (Shared Memory) - Semafori - Code di Messaggi (Sulle sito del corso trovate
INTER-PROCESS COMMUNICATION (IPC) SYSTEM (Bach: the Design of the Unix Operating System ; manuale on-line) IPC. Memoria Condivisa
INTER-PROCESS COMMUNICATION (IPC) SYSTEM (Bach: the Design of the Unix Operating System ; manuale on-line) - Memoria Condivisa (Shared Memory) - Semafori - Code di Messaggi (Sulle sito del corso trovate
System Call per la gestione dei semafori in Linux. Semafori: modello concettuale. Creazione ed inizializzazione di un semaforo
System Call per la gestione dei semafori in Linux Domenico Cotroneo Dipartimento di Informatica e Sistemistica Semafori: modello concettuale Processore D C B (sq)coda proc.sospesi s.count=1 semaforo A
Sistemi operativi - Concetti ed esempi -Settima edizione
Capitolo 6: Sincronizzazione dei processi Capitolo 6: Sincronizzazione dei processi Introduzione Problema della sezione critica Soluzione di Peterson Hardware per la sincronizzazione Semafori Problemi
SISTEMI OPERATIVI 11 settembre 2014 corso A nuovo ordinamento e parte di teoria del vecchio ordinamento indirizzo SR
SISTEMI OPERATIVI 11 settembre 2014 corso A nuovo ordinamento e parte di teoria del vecchio ordinamento indirizzo SR Cognome: Nome: Matricola: 1. Ricordate che non potete usare calcolatrici o materiale
Sistemi Operativi (M. Cesati)
Sistemi Operativi (M. Cesati) Compito scritto del 16 luglio 2014 Nome: Matricola: Corso di laurea: Cognome: Crediti da conseguire: 5 6 9 Scrivere i dati richiesti in stampatello. Al termine consegnare
SEMAFORI SEMAFORI. Sul semaforo sono ammesse solo due operazioni (primitive)
SEMAFORI 1 SEMAFORI Variabile intera non negativa con valore iniziale >= 0 Al semaforo è associata una lista di attesa Qs nella quale sono posti i descrittori dei processi che attono l autorizzazione a
Corso di Laboratorio di Sistemi Operativi
Corso di Laboratorio di Sistemi Operativi Lezione 7 Alessandro Dal Palù email: alessandro.dalpalu@unipr.it web: www.unipr.it/~dalpalu Threads Un thread è l unità di base per l utilizzo della CPU. Composto
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A Pietro Frasca.
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A. 2017-18 Pietro Frasca Lezione 10 Martedì 7-11-2017 Thread a livello kernel Modello da uno a uno La
Inter-Process Communication
Inter-Process Communication (IPC) IPCS 1 1. Code di messaggi 2. Semafori 3. Memoria condivisa send receive 2? 3 p1 p3 p2 CODE DI MESSAGGI Modello di Comunicazione Code di Messaggi Il processo ricevente
GESTIONE DELLA COMUNICAZIONE LOCALE TRA PROCESSI IN UNIX:
GESTIONE DELLA COMUNICAZIONE LOCALE TRA PROCESSI IN UNIX: Il primo meccanismo di comunicazione tra processi locali in ambiente Unix e stato il meccanismo delle pipe. Per processo locale si intende un processo
Principles of Concurrent Programming
Principles of Concurrent Programming Alessio Vecchio alessio.vecchio@unipi.it Dip. di Ingegneria dell Informazione Università di Pisa Tratte da Principi e tecniche di progammazione concorrente, cap. 2
Primitive del linguaggio C relative ai processi
Primitive del linguaggio C relative ai processi Per poter utilizzare le primitive del Linguaggio C relative ai processi occorre includere nel progetto le seguenti librerie: #include #include
Sistemi Operativi (M. Cesati)
Sistemi Operativi (M. Cesati) Compito scritto del 17 settembre 2012 Nome: Matricola: Corso di laurea: Cognome: Crediti da conseguire: 5 6 9 Scrivere i dati richiesti in stampatello. Al termine consegnare
Libreria Linux Threads. Threads nel S.O. Linux. Primitive per la gestione dei thread. Portabilità: libreria pthreads (Posix).
Threads nel S.O. Linux Il thread è un processo leggero che può condividere uno spazio di indirizzi (o parte di esso) con il padre e gli altri processi della gerarchia cui appartiene. Realizzato a livello
Sistemi Operativi (M. Cesati)
Sistemi Operativi (M. Cesati) Compito scritto del 21 settembre 2017 Nome: Matricola: Corso di laurea: Cognome: Crediti da conseguire: 5 6 9 Scrivere i dati richiesti in stampatello. Al termine consegnare
Soluzioni ai problemi di Mutua Esclusione Primitive di sincronizzazione. Soluzioni ai problemi di Mutua EsclusionePrimitive di sincronizzazione
Soluzioni ai problemi di Mutua Esclusione Primitive di sincronizzazione Soluzioni basate su primitive di sincronizzazione Le primitive di sincronizzazione piú comuni sono: Lock (mutex) - realizzati in
Addendum alle chiamate di sistema per la gestione processi. E Mumolo
Addendum alle chiamate di sistema per la gestione processi E Mumolo Definiamo un processo proc.c che scrive l'argomento passato in linea: void main(int argc, char *argv[]){ printf("sono il processo %s\n",
System call per la gestione di processi
System call per la gestione di processi Chiamate di sistema per creazione di processi: fork() sostituzione di codice e dati: exec...() terminazione: exit() sospensione in attesa della terminazione di figli:
System call per la gestione di processi
System call per la gestione di processi Chiamate di sistema per creazione di processi: fork() sostituzione di codice e dati: exec...() terminazione: exit() sospensione in attesa della terminazione di figli:
Programmazione di Sistema
Programmazione di Sistema Massimo Bernaschi Istituto per le Applicazioni del Calcolo Mauro Picone Consiglio Nazionale delle Ricerche Viale Manzoni, 30-00185 Rome - Italy http://www.iac.cnr.it/~massimo
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A Pietro Frasca.
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A. 2014-15 Pietro Frasca Lezione 20 Martedì 16-12-2014 1 System call per la gestione dei processi Creazione
SISTEMI OPERATIVI. Processi in Linux. Giorgio Giacinto Sistemi Operativi
SISTEMI OPERATIVI Processi in Linux 2 Creazione di processi concorrenti» La creazione di un processo figlio consente di far eseguire alcune funzionalità del programma in modo concorrente» Opzione 1 il
Processi: 1. Modelli a stati 2. Rappresentazione di processi 3. Liste di processi e scheduling 4. Processi in sistemi operativi attuali (NT/UNIX)
Sistemi Operativi I Corso di Laurea in Ingegneria Informatica Facolta di Ingegneria, Universita La Sapienza Docente: Francesco Quaglia Processi: 1. Modelli a stati 2. Rappresentazione di processi 3. Liste
LABORATORIO DI SISTEMI OPERATIVI
LABORATORIO DI SISTEMI OPERATIVI Corso di Laurea Triennale in Ingegneria Informatica A.A. 2018/2019 Guglielmo Cola Email: g.cola@iet.unipi.it Web: iet.unipi.it/g.cola Processi in Unix/Linux caratteristiche
Principles of Concurrent Programming
Principles of Giuseppe Anastasi g.anastasi@iet.unipi.it Pervasive Computing & Networking Lab. () Dept. of Information Engineering, University of Pisa Overview Concetti preliminari Interazione fra processi
I Processi nel Sistema Operativo Unix. Gerarchie di processi Unix. Stati di un processo Unix. Stati di un processo Unix.
I Processi nel Sistema Operativo Unix Processi Unix Unix è un sistema operativo multiprogrammato a divisione di tempo: l unità di computazione è il processo. Caratteristiche del processo Unix: processo
Laboratorio di Sistemi Operativi Marzo-Giugno 2008 matricole congrue 0 mod 3
Marzo-Giugno 2008 matricole congrue 0 mod 3 Controllo dei processi - I Controllo dei processi Creazione di nuovi processi Esecuzione di programmi Processo di terminazione Altro 2 1 Identificatori di processi
IPC System V. Code di messaggi
IPC System V Code di messaggi Panoramica coda di messaggi una lista concatenata di messaggi, FIFO semaforo un contatore condiviso, atomicamente modificabile memoria condivisa uno spazio di memoria accessibile
il tipo di parallelismo dipende dal grado di cooperazione
Thread Settembre 2009 programma e parallelismo il tipo di parallelismo dipende dal grado di cooperazione (scambio d informazione) necessario tra attività svolte in parallelo processo macchina virtuale
LABORATORIO DI SISTEMI OPERATIVI
LABORATORIO DI SISTEMI OPERATIVI Corso di Laurea Triennale in Ingegneria Informatica A.A. 2018/2019 Guglielmo Cola Email: g.cola@iet.unipi.it Web: iet.unipi.it/g.cola Thread POSIX nel sistema Linux (parte
Esame Laboratorio di Sistemi Operativi Cognome Nome Mat.
Il compito è costituito da domande chiuse, domande aperte ed esercizi. Non è consentito l uso di libri, manuali, appunti., etc. Tempo massimo 2 ore. Domande chiuse: ogni domanda corrisponde ad un punteggio
Elenco sezioni libro di testo Ed. 5 Tra parentesi le corrispondenze per l'ed. 7.
Elenco sezioni libro di testo Ed. 5 Tra parentesi le corrispondenze per l'ed. 7. Modulo 1 - Architettura del calcolatore Unità 1 - Architettura e funzionamento dei sistemi di elaborazione Lezione 1 - Macchina
Principles of Concurrent Programming
Principles of Giuseppe Anastasi g.anastasi@iet.unipi.it Pervasive Computing & Networking Lab. () Dept. of Information Engineering, University of Pisa Overview Concetti preliminari Interazione fra processi
Sincronizzazione dei processi. Capitolo 5 -- Silberschatz
Sincronizzazione dei processi Capitolo 5 -- Silberschatz Processi cooperanti Nei moderni SO, i processi vengono eseguiti concorrentemente Possono essere interrotti in qualunque momento nel corso della
ACSO Programmazione di Sistema e Concorrente
ACSO Programmazione di Sistema e Concorrente P2 Modello Thread 2/12/2015 programma e parallelismo il tipo di parallelismo dipende dal grado di cooperazione (scambio di informazione) necessario tra attività
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A Pietro Frasca.
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A. 2016-17 Pietro Frasca Lezione 20 Giovedì 22-12-2016 Comunicazione: pipe In Unix, processi possono comunicare
TECN.PROG.SIST.INF. Creazione di un processo in Windows. Roberta Gerboni
Roberta Gerboni // Funzione delle API di Windows // Crea un nuovo processo e il relativo thread primario. // Il nuovo processo viene eseguito nel contesto di protezione // del processo chiamante BOOL WINAPI
Sistemi Operativi (M. Cesati)
Sistemi Operativi (M. Cesati) Compito scritto del 16 febbraio 2016 Nome: Matricola: Corso di laurea: Cognome: Crediti da conseguire: 5 6 9 Scrivere i dati richiesti in stampatello. Al termine consegnare
Sistemi operativi. Lez. 9: primitive per la concorrenza i semafori
Sistemi operativi Lez. 9: primitive per la concorrenza i semafori Disabilitazione interrupt Due processi possono trovarsi in sezione critica simultaneamente solo perché chi vi è entrato per primo è stato
System call fcntl e record locking
System call fcntl e record locking Esempio: prenotazione di voli aerei La compagnia ACME Airlines usa un sistema di prenotazione dei voli basato su unix. Possiede due uffici per la prenotazione, A e B,
Semafori. Semafori classici con i thread POSIX 2
Semafori classici Semafori I semafori sono primitive, implementate attraverso dei contatori, fornite dal sistema operativo per permettere la sincronizzazione tra processi e/o thread. Per queste primitive
GESTIONE DELLE PERIFERICHE D INGRESSO/USCITA ARGOMENTI
GESTIONE DELLE PERIFERICHE D INGRESSO/USCITA ARGOMENTI Compiti del sottosistema di I/O Architettura del sottosistema di I/O Gestore di un dispositivo di I/O Gestione e organizzazione dei dischi COMPITI
uid_t getuid(void); //real-user-id del chiamante getegid(void); //effective-user-id del chiamante gid_t getgid(void); //real-group-id del chiamante
#include // typedef long pid_t; // typedef long uid_t; // typedef long gid_t; pid_t getpid(void); //pid del chiamante; pid_t getppid(void); //pid del padre uid_t getuid(void); //real-user-id
Esercitazione [3] Sincronizzazione inter-processo
Esercitazione [3] Sincronizzazione inter-processo Leonardo Aniello - aniello@dis.uniroma1.it Daniele Cono D'Elia - delia@dis.uniroma1.it Sistemi di Calcolo - Secondo modulo (SC2) Programmazione dei Sistemi
Inter-Process Communication
Inter-Process Communication C. Baroglio a.a. 2002-2003 1 Introduzione In Unix i processi possono essere sincronizzati utilizzando strutture dati speciali, appartenti al pacchetto IPC (inter-process communication).
Chiamata di procedura remota
Con gli strumenti gia` visti, si puo` realizzare come segue: lato chiamante: send asincrona immediatamente seguita da una receive lato chiamato: una receive seguita, al termine dell azione richiesta, da
Sistemi Operativi (M. Cesati)
Sistemi Operativi (M. Cesati) Compito scritto del 19 settembre 2016 (Traccia A) Nome: Matricola: Corso di laurea: Cognome: Crediti da conseguire: 5 6 9 Scrivere i dati richiesti in stampatello. Al termine
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A Pietro Frasca.
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A. 2018-2019 Pietro Frasca Lezione 5 Martedì 16-10-2018 Operazioni sui processi Nella maggior parte dei
Chiamata di procedura remota
Chiamata di procedura remota Meccanismo di comunicazione e sincronizzazione tra processi in cui un processo che richiede un servizio ad un altro processo rimane sospeso fino al completamento del servizio
Sistemi Operativi (M. Cesati)
Sistemi Operativi (M. Cesati) Compito scritto del 19 febbraio 2013 Nome: Matricola: Corso di laurea: Cognome: Crediti da conseguire: 5 6 9 Scrivere i dati richiesti in stampatello. Al termine consegnare
GESTIONE DELLE PERIFERICHE D INGRESSO/USCITA ARGOMENTI
GESTIONE DELLE PERIFERICHE D INGRESSO/USCITA ARGOMENTI Compiti del sottosistema di I/O Architettura del sottosistema di I/O Gestore di un dispositivo di I/O COMPITI DEL SOTTOSISTEMA DI I/O 1. Nascondere
CAPITOLO 22 PROBLEMA DEL PRODUTTORE/CONSUMATORE
CAPITOLO 22 PROBLEMA DEL PRODUTTORE/CONSUMATORE Il problema del produttore/consumatore Il primo approccio alla risoluzione del problema del produttore/consumatore considera un buffer infinito presentato
CAPITOLO 17 PROBLEMI DEL PRODUTTORE/CONSUMATORE v1
CAPITOLO 17 PROBLEMI DEL PRODUTTORE/CONSUMATORE v1 PRODUTTORE/CONSUMATORE Il problema del produttore/consumatore è uno dei problemi più comuni di concorrenza tra processi. Il problema presenta uno o più
Java Virtual Machine. Indipendenza di java dalla macchina ospite. I threads in Java
programmi sorgente: files.java compilatore Indipendenza di java dalla macchina ospite Programmi java Programmi java Programmi java files.class bytecode linker/loader bytecode bytecode Java API files.class
SISTEMI OPERATIVI - canale 2
DIPARTIMENTO DI INGEGNERIA ELETTRICA ELETTRONICA E INFORMATICA Corso di laurea in Ingegneria informatica Anno accademico 2016/2017-2 anno SISTEMI OPERATIVI - canale 2 ING-INF/05-6 CFU - 1 semestre Docente
Cenni ai Problemi classici di Sincronizzazione Processi Concorrenti. E. Mumolo
Cenni ai Problemi classici di Sincronizzazione Processi Concorrenti E. Mumolo Problemi classici Problemi di mutua esclusione proposti nel corso degli anni Modelli di problemi reali Problema del produttore
Sistemi Operativi (M. Cesati)
Sistemi Operativi (M. Cesati) Compito scritto del 13 febbraio 2017 Nome: Matricola: Corso di laurea: Cognome: Crediti da conseguire: 5 6 9 Scrivere i dati richiesti in stampatello. Al termine consegnare
GESTIONE DELLE PERIFERICHE D INGRESSO/USCITA COMPITI DEL SOTTOSISTEMA DI I/O ARGOMENTI
GESTIONE DELLE PERIFERICHE D INGRESSO/USCITA ARGOMENTI Compiti del sottosistema di I/O Architettura del sottosistema di I/O Gestore di un di I/O 1. Nascondere al programmatore i dettagli delle interfacce
LINUX: struttura generale
LINUX: struttura generale User Interface The layers of a UNIX system. 1 Processi in LINUX Ogni processo nasce con un solo thread Un processo gira in modalità utente; quando effettua una system call passa
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A Pietro Frasca.
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A. 2017-18 Pietro Frasca Lezione 7 Giovedì 26-10-2017 1 Comunicazione tra processi I processi in esecuzione
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A Pietro Frasca.
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A. 2017-18 Pietro Frasca Lezione 9 Giovedì 2-11-2017 Comunicazione con pipe Oltre che con la memoria condivisa
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A Pietro Frasca.
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A. 2016-17 Pietro Frasca Lezione 21 Martedì 10-01-2017 Sincronizzazione tra thread Per risolvere problemi
Esercizi di utilizzo del semaforo semplice di competizione per l'uso di una risorsa comune
Esercizi di utilizzo del semaforo semplice di competizione per l'uso di una risorsa comune a) Uso di una risorsa condivisa Siano P 1, P 2, P 3,, P k i processi che condividono l uso di una risorsa comune
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A Pietro Frasca.
Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A. 2018-2019 Pietro Frasca Lezione 9 Martedì 6-11-2018 I thread nello standard POSIX: la libreria pthreads
SISTEMI OPERATIVI. Semafori. Semafori
SISTEMI OPERATIVI 04.a Semafori Semafori Approfondimento sulla mutua escluone Manipolazione di risorse mutex Strategie di soluzione Lock e Un Primitive semaforiche 1 Approfondimento sulla mutua escluone
Sistemi Operativi 1. Lezione III: Concetti fondamentali. Mattia Monga. 7 marzo 2008
1 Dip. di Informatica e Comunicazione Università degli Studi di Milano, Italia mattia.monga@unimi.it 7 marzo 2008 1 c 2008 M. Monga. Creative Commons Attribuzione-Condividi allo stesso modo 2.5 Italia
Sistemi Operativi 1. Mattia Monga. 7 marzo Dip. di Informatica e Comunicazione Università degli Studi di Milano, Italia
1 Dip. di Informatica e Comunicazione Università degli Studi di Milano, Italia mattia.monga@unimi.it 7 marzo 2008 1 c 2008 M. Monga. Creative Commons Attribuzione-Condividi allo stesso modo 2.5 Italia