INFOPedia : LSOMuseo

HomePage :: Categorie :: Indice :: Ultime modifiche :: Ultimi commenti :: Login/Registrazione
La versione più recente è stata modificata il 2006-06-08 17:50:36 da AntarellO [corretta GetRandom]

Aggiunzioni:
#define GetRandom(min,max) (rand()%((int)(max)-(min)+1)+(min));

Omissioni:
#define GetRandom(min,max) GetRandom(min,max) (rand()%((int)(max)-(min)+1)+(min));



Modificato il 2006-06-08 17:50:13 da AntarellO [corretta GetRandom]

Aggiunzioni:
#define GetRandom(min,max) GetRandom(min,max) (rand()%((int)(max)-(min)+1)+(min));

Omissioni:
#define GetRandom(min,max) (rand()%(int)(max)+(min));



Modificato il 2006-06-07 23:31:40 da DenteDiLupo [mancava il tipo di linguaggio per il code]

Aggiunzioni:
%%(cpp)

Omissioni:
%%




Modificato il 2006-06-07 23:30:40 da DenteDiLupo [Inserita versione più pulita e compatta]

Aggiunzioni:
%%
IMPORTO LE LIBRERIE NECESSARIE


COSTANTI E FUNZIONI

#define randomize(num) srand((unsigned)time(NULL)*(num));
#define GetRandom(min,max) (rand()%(int)(max)+(min));
#define Capienza 3
void visitatore(int *id2);

VARIABILI

HANDLE stanza[3];

MAIN

void main(){
int i,id=0;
for(i=0;i<3;i)
stanza[i] = CreateSemaphore(NULL,Capienza,Capienza,NULL);

while(getch()!= 'q'){ ogni volta che premo un pulsante creo un visitatore, q per uscire
id;
CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)visitatore,(LPVOID) &id,0,NULL);

THREAD

void visitatore(int *id2){
int i,visitato[3] ={0,0,0},finito = 0,id=*id2,tempo;
while (finito
0){ fino a quando finito è uguale a zero (fino a quando non ho visitato le 3 stanze)
for(i=0;i<3;i){ Ciclo per ogni stanza
if ((visitato[i]
0) && ((WaitForSingleObject(stanza[i],500)) != WAIT_TIMEOUT)) se la stanza non è stata ancora visitata e la Wait non va in Timeout
printf("Visitatore %d ENTRA nella stanza %d\n",id,i);
tempo = GetRandom(1000,3000)
Sleep(tempo);
visitato[i] =1;
printf("Visitatore %d ESCE dalla stanza %d\n",id,i);
ReleaseSemaphore(stanza[i],1,NULL);
rilascio il semaforo
}
if ((visitato[0]
1) &&(visitato[1]
1) && (visitato[2]
1)) setta finito ad 1 quando vengono visitate tutte e 3 le stanze
finito=1;
printf("Visitatore *%d* lascia il museo\n",id);

Omissioni:
%%(cpp)

Importo le librerie necessarie...

#include <stdlib.h>
#include <process.h>

Definisco funzioni e le procedure...

#define randomize srand((unsigned)time(NULL))
#define GetRandom(min,max) ((rand()%(int)(max)+(min)))
void turista(int id);

Definisco costanti e le variabilo globali...

#define T 1000
unità di tempo
#define Stanze 3 Numero di stanze del museo
#define
Capienza 3 Numero di persone contenute in ogni stanza (MAX)
HANDLE H_Semaphore_Stanza[Stanze]; array dei semafori,uno per ogni stanza
CRITICAL_SECTION Stampa;
no comment..

MAIN...

void main()
{
int i,count=0;
inizializzo la sezione critica per la stampa
InitializeCriticalSection(&Stampa);
Creo i semafori
for (i=0;i<Stanze;i)
{
H_Semaphore_Stanza[i] = CreateSemaphore(NULL,Capienza,Capienza,NULL);
while (getch() != 'q')
{
CreateThread(NULL,0,(LPTHREAD_START_ROUTINE) turista,(LPVOID) count,0,NULL);

Thread turisti...

void turista(int id)
{
int i,visitate[Stanze];
bool finito = false;
inizializzo a zero l'array delle stanze visitate
for (i=0;i<
Stanze;i)
visitate[i] = 0;
while (finito
false) {
for (i=0;i<Stanze;i)
{
Controllo le stanze da visitare
if (visitate[i]
0)
Controllo se è disponibile un posto nella stanza non ancora visitata, e verifico che l'attesa non vada in timeout.
if ( WaitForSingleObject(H_Semaphore_Stanza[i],T * 10) != WAIT_TIMEOUT )
{
EnterCriticalSection(&Stampa);
printf("* il turista %i entra nella stanza%i \n",id,i);
visitate[i] = 1;
LeaveCriticalSection(&Stampa);
il turista si talia i cuatri...
randomize;
Sleep(GetRandom(1,10)*T);
il turista lascia la stanza...
EnterCriticalSection(&Stampa);
ReleaseSemaphore(H_Semaphore_Stanza[i],1,NULL);
printf("* * * il turista %i lascia la stanza%i \n",id,i);
LeaveCriticalSection(&Stampa);
}
else
printf("
> il turista %i s'è rotto i coglioni d'aspettare la stanza %i <
\n",id,i);
}

Controlliamo se il visitatore ha visitato tutte le stanze del museo
finito = true;
for (i=0;i<
Stanze;i)
{
finito = finito && visitate[i]; lo ziooo...
printf("il turista %i lascia il museo...\n\n\n",id);




La versione più vecchia di questa pagina è stata modificata il 2006-05-29 12:26:59 da ChiptuttoFuso [Creata pagina]
Vista della pagina:

PROBLEMA DEL MUSEO


In un museo si possono visitare tre stanze ma per sicurezza in ogni stanza non può avere più di 10 visitatori per volta.

I visitatori
arrivano al museo
finchè non visitano le tre stanze
o scelgono una delle tre stanze da visitare
o attende che possa entrare nella stanza
o visita la stanza per un tempo randomica
o esce dalla stanza

Si sviluppi il programma che simuli la situazione precedente considerando le funzioni "visitatore" come threads di un unico processo:
a) descrivere le scelte fatte e giustificarle.
b) scrivere il codice delle funzioni in C in ambiente windows o linux.
c) motivare lassenza di deadlock.

Assenza di deadlock è verificata perchè neghiamo tutte le condizioni (ndr Diciamo che ne siamo abbastanza sicuri, ma non ci mettiamo la mano sul fuoco.... )


//----------------------------------------------------------------------------------------------------------------------------------------------------
// Importo le librerie necessarie...
//----------------------------------------------------------------------------------------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <process.h>
#include <windows.h>
#include <conio.h>
#include <time.h>



//----------------------------------------------------------------------------------------------------------------------------------------------------
// Definisco funzioni e le procedure...
//----------------------------------------------------------------------------------------------------------------------------------------------------
#define randomize srand((unsigned)time(NULL))
#define GetRandom(min,max) ((rand()%(int)(max)+(min)))
void turista(int id);



//----------------------------------------------------------------------------------------------------------------------------------------------------
// Definisco costanti e le variabilo globali...
//----------------------------------------------------------------------------------------------------------------------------------------------------
#define T 1000                            //unità di tempo
#define __Stanze 3                        //Numero di stanze del museo
#define __Capienza 3                    //Numero di persone contenute in ogni stanza (MAX)
HANDLE H_Semaphore_Stanza[__Stanze];    //array dei semafori,uno per ogni stanza
CRITICAL_SECTION Stampa;                //no comment..



//----------------------------------------------------------------------------------------------------------------------------------------------------
// MAIN...
//----------------------------------------------------------------------------------------------------------------------------------------------------
void main()
{
    int i,count=0;

    //inizializzo la sezione critica per la stampa
    InitializeCriticalSection(&Stampa);

    //Creo i semafori
    for (i=0;i<__Stanze;i++)
    {
        H_Semaphore_Stanza[i] = CreateSemaphore(NULL,__Capienza,__Capienza,NULL);
    }

    while (getch() != 'q')
    {
        CreateThread(NULL,0,(LPTHREAD_START_ROUTINE) turista,(LPVOID) ++count,0,NULL);
    }
}



//----------------------------------------------------------------------------------------------------------------------------------------------------
// Thread turisti...
//----------------------------------------------------------------------------------------------------------------------------------------------------
void turista(int id)
{
    int i,visitate[__Stanze];
    bool finito = false;


    //inizializzo a zero l'array delle stanze visitate
    for (i=0;i<__Stanze;i++)
        visitate[i] = 0;

    while (finito == false)
    {
        for (i=0;i<__Stanze;i++)
        {
            //Controllo le stanze da visitare
            if (visitate[i] == 0)
            {
                //Controllo se è disponibile un posto nella stanza non ancora visitata, e verifico che l'attesa non vada in timeout.
                if ( WaitForSingleObject(H_Semaphore_Stanza[i],T * 10) != WAIT_TIMEOUT )
                {
                    EnterCriticalSection(&Stampa);
                        printf("* il turista %i entra nella stanza%i \n",id,i);
                        visitate[i] = 1;
                    LeaveCriticalSection(&Stampa);

                    //il turista si talia i cuatri...
                    randomize;
                    Sleep(GetRandom(1,10)*T);

                    //il turista lascia la stanza...
                    EnterCriticalSection(&Stampa);
                        ReleaseSemaphore(H_Semaphore_Stanza[i],1,NULL);
                        printf("* * * il turista %i lascia la stanza%i \n",id,i);
                    LeaveCriticalSection(&Stampa);
                }
                else
                    printf("-----> il turista %i s'è rotto i coglioni d'aspettare la stanza %i <-----\n",id,i);
            }   
        }
       
        //Controlliamo se il visitatore ha visitato tutte le stanze del museo
        finito = true;
        for (i=0;i<__Stanze;i++)
        {
            finito = finito && visitate[i]; // lo ziooo...
        }
    }

    printf("il turista %i lascia il museo...\n\n\n",id);
}




Torna a Lab Sistemi Operativi
Valid XHTML 1.0 Transitional :: Valid CSS :: Powered by Wikka Wakka Wiki 1.1.6.1
La pagina è stata generata in 0.1871 secondi