Appunti per Scuola e Università
Umanistiche
Appunti e tesine di tutte le materie per gli studenti delle scuole medie riguardanti le materie umanistiche: dall'italiano alla storia riguardanti le materie umanistiche: dall'italiano alla storia 
Scientifiche
Appunti, analisi, compresione per le scuole medie suddivisi per materie scientifiche, per ognuna troverai appunti, dispense, esercitazioni, tesi e riassunti in download.
Tecniche
Gli appunti, le tesine e riassunti di tecnica amministrativa, ingegneria tecnico, costruzione. Tutti gli appunti di AppuntiMania.com gratis!
Appunti
informatica
C Computer Database Internet Java
Linux unix Reti


AppuntiMania.com » Informatica » Appunti di c » Problemi di mutua esclusione nel modello a memoria comune

Problemi di mutua esclusione nel modello a memoria comune




Visite: 510Gradito: [ Picolo appunti ]
Leggi anche appunti:

Gli interrupt: utilizzo


Gli interrupt: utilizzo Gli interrupt sono routine, normalmente operanti a livello

L'i/o e la gestione dei file


L'I/O e la gestione dei file Per Input/Output (I/O) si intende l'insieme delle

Allocazione dinamica della memoria


Allocazione dinamica della memoria Quando è dichiarata una variabile, il compilatore



Scarica gratis Problemi di mutua esclusione nel modello a memoria comune

Problemi di mutua esclusione nel modello a memoria comune

VI) Scrivere una applicazione concorrente che implementi il problema dei  Lettori/Scrittori nella variante che prevede che essi accedano ad un pool di buffer di memoria condivisa, con attesa indefinita sia dei processi scrittori che dei processi lettori.



Descrizione: Il programma seguente implementa il problema dei Lettori/Scrittori (più di uno) nel caso in cui si assuma che sia i processi lettori che i processi scrittori abbiano (quando attivi) la massima priorità sui processi dell'altra categoria, sicché ambedue le classi di processi possono subire starvation. I vincoli possono essere così riassunti:

      Il processo scrittore attivo opera ogni volta una “sovrascrittura” del contenuto del buffer.

      Finchè è attivo un processo scrittore i processi lettori e gli altri processi scrittori devono attendere (a garanzia della consistenza del contenuto del buffer).

      Finchè sono attivi uno o più processi lettori i processi scrittori devono attendere, e finquando è attivo almeno un processo lettore tutti i processi lettori che sopraggiungono hanno diritto di prelazione rispetto ad eventuali processi scrittori già in attesa.

      Finchè è attivo un processo scrittore i processi lettori devono attendere, e finquando è attivo almeno un processo scrittore tutti i processi scrittori che sopraggiungono hanno diritto di prelazione rispetto ad eventuali processi lettori già in attesa.

 Semafori.H (L'implementazione è quella indicata per il programma I)

#include <sys/types.h> 

#include <sys/ipc.h>

#include <sys/sem.h>

void Init_Sem(int, int);          //Inizializza Semaforo

 

void Wait_Sem(int, int);        //Wait su Semaforo

  

void Signal_Sem(int, int);     //Signal su Semaforo

int Awaiting_Sem(int, int);    //Restituisce il numero di processi in attesa su Semaforo

 Lett_Scrit_Starv.H

#include <stdio.h>

#include”semafori.h”

typedef struct Buffer;

void Init_Buffer(Buffer*);                                         //Inizializza il vettore

void Init_Semafori(int);                                             //Inizializza i semafori

void Inizio_Lettura(Buffer*, int);                              //Acquisizione del buffer in lettura

char Lettura(Buffer*);                                                            //Lettura del buffer

void Fine_Lettura(Buffer*, int);                                //Rilascio del buffer dopo una lettura

void Inizio_Scrittura(Buffer*, int);                           //Acquisizione del buffer per la scrittura

void Scrittura(char, Buffer*);                                    //Scrittura del buffer

void Fine_Scrittura(Buffer*, int);                             //Rilascio del buffer dopo una scrittura

          

 Lett_Scrit_Starv.C

     

#include “Lett_Scrit_Starv.h”    

#define MUTEX_LETT 0                                                      //Definizione di MACRO per l'accesso ai semafori

#define MUTEX_SCRIT 1

#define MUTEX 2

#define SYNCH 3

#define INITIALIZE(S,V) Init_Sem(ID_Sem,S,V)

#define WAIT(S) Wait_Sem(ID_Sem,S)

#define SIGNAL(S) Signal_Sem(ID_Sem,S)

void Init_Buffer(Buffer* B)

void Init_Semafori(int ID_Sem)

void Inizio_Lettura(Buffer* B, int ID_Sem)

            SIGNAL(MUTEX_LETT);

}

char Lettura(Buffer* B)

void Fine_Lettura(Buffer* B, int ID_Sem)

            SIGNAL(MUTEX_LETT);

}

void Inizio_Scrittura(Buffer* B, int ID_Sem)




            SIGNAL(MUTEX_SCRIT);

            WAIT(MUTEX);

}

void Scrittura(char value, Buffer* B)

void Fine_Scrittura(Buffer* B, int ID_Sem)

            SIGNAL(MUTEX_SCRIT);

}

 Programma VI.C

#include <stdio.h>         

#include <sys/shm.h>     

#include <sys/wait.h>         

#include 'lett_scrit_starv.h'

#define DIM sizeof(Buffer)               //Dimensione dell'area di memoria condivisa

#define NUM_LETT 5                                   //Numero di processi lettori

#define NUM_SCRIT 2                                  //Numero di processi scrittori

void main()

    

     Ptr_Buf=(Buffer*)shmat(ID_Buf, 0, 0);               //Il segmento allocato viene annesso al segmento dati

                                                                                    //del processo al primo indirizzo disponibile così come

                                                                                    //specificato dal sistema

     if (Ptr_Buf==(Buffer*)-1)

     Init_Buffer(Ptr_Buf);                                            //Inizializzazione del Buffer

     //----- CREAZIONE SEMAFORI -----

     key_t Key_Sem=IPC_PRIVATE;                                      //Chiave del semaforo/i

     int ID_Sem;                                                                       //Identificatore del semaforo/i

     ID_Sem=semget(Key_Sem, 4, IPC_CREAT|0664);         //Viene allocato un gruppo di semafori di cardinalità 4,

                                                                                    //viene associato al gruppo un ID e viene creata una

                                                                                    //struttura dati ausiliaria che consenta di gestirlo

                                                                                    //RW per User, RW per Gruppo, R only per Others

     if (ID_Sem==-1)

     Init_Semafori(ID_Sem);                                        //Inizializzazione dei semafori

     //----- GENERAZIONE FIGLI SCRITTORI -----

     for(i=0; i<NUM_SCRIT; i++) else if (!pid)

                        Inizio_Scrittura(Ptr_Buf, ID_Sem);

                        Scrittura(value, Ptr_Buf);

                        Fine_Scrittura(Ptr_Buf, ID_Sem);

                        exit(0);                                                            //Il figlio Scrittore termina correttamente

     }

     } //End For NUM_SCRIT

     //----- GENERAZIONE FIGLI LETTORI -----

     for(i=0; i<NUM_LETT; i++) else if (!pid)

     } //End For NUM_LETT

     //----- SINCRONIZZAZIONE DEL PADRE CON I FIGLI -----

     for(i=0; i<NUM_SCRIT+NUM_LETT; i++)

     //----- RILASCIO MEMORIA CONDIVISA E SEMAFORO -----

    

     shmctl(ID_Buf, IPC_RMID, 0);

   semctl(ID_Sem, 0, IPC_RMID);

}

Scarica gratis Problemi di mutua esclusione nel modello a memoria comune
Appunti su:







Accedi al tuo account
Scarica 100% gratis e Invia appunti, tesine, riassunti

Registrati ora Password dimenticata?
  • Appunti superiori
  • In questa sezione troverai sunti esame, dispense, appunti universitari, esercitazioni e tesi, suddivisi per le principali facoltà.
  • Università
  • Appunti, dispense, esercitazioni, riassunti direttamente dalla tua aula Universitaria
  • all'Informatica
  • Introduzione all'Informatica, Information and Comunication Tecnology, componenti del computer, software, hardware ...