Problema dei Pizzaioli
In una pizzeria molto frequentata vi lavarono due pizzaioli. L’unico forno disponibile può contenere un massimo di 8 pizze quindi i pizzaioli devono condividere l’unico forno disponibile. La vita lavorativa dei pizzaioli quindi consiste
Fino a quando ci sono ordinazioni
1) Prende una ordinazione con un numero n random di pizze da 1 a 10 da preparare
2) Prepara le pizze in un tempo t=n*tp
3) Inforna un numero di pizze m che può infornare
4) Aspetta un tempo t=tc in cui le pizze vengono cotte
5) Se ha cotto tutte le pizze va al punto 1 se no va al punto 3
a) Sviluppare in linguaggio C un programma che simuli la situazione descritta commentando le scelte fatte.
b) Descrivere una possibile situazione gestita da un Sistema Operativo che si avvicini alla situazione descritta.
NUOVA VERSIONE
//-----------------------------------------------------
// IMPORTO LE LIBRERIE
//-----------------------------------------------------
#include <stdio.h>
#include <windows.h>
#include <conio.h>
#include <time.h>
//-----------------------------------------------------
// COSTANTI E FUNZIONI
//-----------------------------------------------------
#define randomize(num) srand((unsigned)time(NULL)*(num))
#define GetRandom(min,max) (rand()%((int)(max)-(min)+1)+(min))
#define __Capienza 8
#define __Tp 750
#define __Tc 3036
void pizzaiolo(int *id2);
//-----------------------------------------------------
// VARIABILI
//-----------------------------------------------------
HANDLE forno;
//-----------------------------------------------------
// MAIN
//-----------------------------------------------------
void main(){
int id1=1,id2=2;
//creo il semaforo per il forno
forno = CreateSemaphore(NULL,__Capienza,__Capienza,NULL);
//creo i 2 pizzaioli con id diversi
CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)pizzaiolo,(LPVOID) &id1,0,NULL);
CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)pizzaiolo,(LPVOID) &id2,0,NULL);
getch(); //quando premo un tasto termino il programma
}
//-----------------------------------------------------
// THREAD
//-----------------------------------------------------
void pizzaiolo(int *id2){
int id,n_pizze,count;
id = *id2;
while(1){
randomize(id); //randomizzo il seme
n_pizze = GetRandom(1,10); //Prendo ordinazione
printf("Pizzaiolo %d ORDINAZIONE %d pizze\n",id,n_pizze);
Sleep(__Tp*n_pizze); //preparo le pizze
printf("Pizzaiolo %d \t PREPARATO %d pizze\n",id,n_pizze);
while (n_pizze != 0){ //ciclo che termina quando non ho più pizze da infornare
count = 0; //pizze infornabili
while ((n_pizze != count) && (WaitForSingleObject(forno,500) != WAIT_TIMEOUT)) //fino a che count raggiunge le pizze da infornare e non vado in timeout per il Semaforo
count++; //incremento il numero di pizze infornabili
if(count != 0) //se nn c'è questo controllo si infornato 0 pizze e ReleaseSemaphore dà errore
{
n_pizze -= count; //Nuovo valore delle pizze da infornare
printf("Pizzaiolo %d \t\t INFORNATO %d pizze\n",id,count);
Sleep(__Tc); //aspetto il tempo di cottura
printf("Pizzaiolo %d \t\t\t SFORNA %d pizze (%d restanti)\n",id,count,n_pizze);
ReleaseSemaphore(forno,count,NULL);
}
}
}
}
VECCHIA VERSIONE
//----------------------------------------------------------------------------------------------------------------
// Importo le librerie necessarie...
//----------------------------------------------------------------------------------------------------------------
#include <windows.h>
#include <time.h>
#include <stddef.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
//----------------------------------------------------------------------------------------------------------------
// Dichiaro le costanti e le variabili globali...
//----------------------------------------------------------------------------------------------------------------
#define __Capienza 8 //Definisco una costante per la capienza di ciascun forno
#define __Forni 1 //Definisco una costante per il numeri di forni
#define __Pizzaioli 2 //Definisco una costante per il numero di pizzaioli
#define __tp 1000 //Definisco il tempo di preparazione per ogni singola pizza
#define __tc 3000 //Definisco il tempo di cottura per ogni singola pizza
HANDLE H_Semaphore_Forni
[__Forni
];
//l'array di semafori dei forni
HANDLE H_Thread_Pizzaiolo
[__Pizzaioli
];
//l'array di thread dei pizzaioli
int fine=
0;
//----------------------------------------------------------------------------------------------------------------
// Dichiaro le funzioni e le procedure...
//----------------------------------------------------------------------------------------------------------------
#define GetRandom( min, max ) ((rand() % (int)(((max) + 1) - (min))) + (min))
#define randomize srand((unsigned)time(NULL))
void Pizzaiolo
(int *i
);
HANDLE Finito
(LPDWORD lpdwParam
);
//----------------------------------------------------------------------------------------------------------------
// Main...
//----------------------------------------------------------------------------------------------------------------
void main
()
{
int i;
//Creo il thread per gestire la fine...
CreateThread
(NULL,
0,
(LPTHREAD_START_ROUTINE
) Finito,
(LPVOID
) &fine,
0,
NULL);
//Creo un semaforo per ogni forno...
for(i=
0;i<__Forni;i++
)
H_Semaphore_Forni
[i
] = CreateSemaphore
(NULL, __Capienza,__Capienza,
NULL);
//Creo i due thread,uno per ogni pizzaiolo
for (i=
0;i<__Pizzaioli;i++
)
{
H_Thread_Pizzaiolo
[i
] = CreateThread
(NULL,
0,
(LPTHREAD_START_ROUTINE
) Pizzaiolo ,
(LPVOID
) &i ,
0,
NULL);
//Mando in sleep il processo,quanto basta per fare iniziare il thread creato con il corretto valore di i.
Sleep
(1000);
}
//Inizio attesa attiva
while (fine ==
0);
//Chiudo le risorse...
for (i=
0;i<__Forni;i++
)
CloseHandle
(H_Semaphore_Forni
[i
]);
for (i=
0;i<__Pizzaioli;i++
)
TerminateThread
(H_Thread_Pizzaiolo
[i
],
0);
}
//----------------------------------------------------------------------------------------------------------------
// Funzione che gestisce i pizzaioli...
//----------------------------------------------------------------------------------------------------------------
void Pizzaiolo
(int *i
)
{
DWORD result,forno_libero
[__Capienza
];
int numero_pizze,pizze_infornate,pizze_da_infornare;
int whois;
whois = *i +
1;
while (fine==
0)
{
//Il Pizzaiolo prende l'ordinazione delle pizze,al massimo 10
randomize;
numero_pizze=GetRandom
(1,
10);
pizze_infornate=
0;
//le pizze vengono preparate
printf("***** il Pizzaiolo%i sta preparando %i pizze... *****\n\n",whois,numero_pizze
);
Sleep
(numero_pizze * __tp
);
do
{
while ((pizze_infornate<__Capienza
) &&
(pizze_infornate<numero_pizze
))
{
result=WaitForMultipleObjects
(__Forni,H_Semaphore_Forni,
false, INFINITE
);
forno_libero
[pizze_infornate
]=result-WAIT_OBJECT_
0+
1;
printf(" il Pizzaiolo%i mette la pizza%i nel forno%d\n",whois,++pizze_infornate,forno_libero
[pizze_infornate
]);
}
printf(" \nil Pizzaiolo%i ha infornato attualmente %i pizze...\n",whois,pizze_infornate
);
Sleep
(__tc
);
printf(" le %i pizze del Pizzaiolo%i sono cotte!! Buon Appetito...\n",pizze_infornate,whois
);
for (int i=
0;i<pizze_infornate;i++
)
ReleaseSemaphore
(H_Semaphore_Forni
[forno_libero
[i
]-
1],
1,
NULL);
pizze_da_infornare = numero_pizze - pizze_infornate;
printf("\n-----> ----->il Pizzaiolo%i deve ancora infornare %i pizze\n\n\n",whois,pizze_da_infornare
);
numero_pizze = numero_pizze - pizze_infornate;
pizze_infornate=
0;
}
while (pizze_da_infornare>
0);
}
}
//----------------------------------------------------------------------------------------------------------------
// Procedura che determina la fine del programma...
//----------------------------------------------------------------------------------------------------------------
HANDLE Finito
(LPDWORD lpdwParam
)
{
int *fine;
fine=
(int*
)lpdwParam;
getch
();
*fine=
1;
return 0;
}
Torna a Lab Sistemi Operativi
There are 3 comments on this page. [Visualizza commenti]