// Mettre en attente un processus s'il doit attendre à la barrière
private void attenteSiBarriere(Processus processus)
{
foreach (Barriere barriere in lstBarrieres)
{
if (barriere.getBarrierePassee() == false)
{
foreach (KeyValuePair <int, int> kvp in barriere.getBarriere())
{
if (processus.getPID() == kvp.Key)
{
if (processus.getNbInstructionsExecutees() == kvp.Value)
{
processus.mettreEnAttenteBarriere();
processus.setEtat(Enums.etatProcessus.Pret);
foreach (Thread thread in processus.getThreads())
{
thread.setEtat(Enums.etatThread.Pret);
updateInfoThread(processus);
}
}
}
}
}
}
}
// Algorithme d'ordonnancement PP
private List <Processus> OrderListProcessusPP(List <Processus> newlistProcessus)
{
List <Processus> newList = new List <Processus>();
foreach (Processus processus in newlistProcessus)
{
if (Enums.etatProcessus.Pret.Equals(processus.getEtat()))
{
newList.Add(processus);
}
}
int lenght = newList.Count;
while (lenght > 0)
{
for (int i = 0; i < lenght - 1; i++)
{
if (newList.Count == 1)
{
break;
}
else if (newList[i].getPriorite() < newList[i + 1].getPriorite())
{
Processus processus = newList[i];
newList[i] = newList[i + 1];
newList[i + 1] = processus;
}
}
lenght = lenght - 1;
}
return(newList);
}
// Update les informations d'un thread
private void updateInfoThread(Processus processus)
{
int indexThread = 0;
foreach (Thread thread in processus.getThreads())
{
indexThread = getThreadAffiche(thread);
dgv_RAM.Columns[indexThread].Name = thread.getInfoThread(processus);
}
}
// Trouver le nombre d'instructions que possède un processus
private int trouverNbInstructionsProcessus(Processus processus)
{
int nbInstructions = 0;
foreach (Thread thread in processus.getThreads())
{
nbInstructions += thread.getInstructions().Count;
}
return(nbInstructions);
}
// Obtenir les infos d'un thread
public string getInfoThread(Processus processus)
{
string infos = "NomProcessus: " + this.processNom + "\n\t";
infos += "PID: " + this.PID + "\n\t";
infos += "TID: " + this.TID + "\n\t";
infos += "PrioriteProcessus: " + this.priorite + "\n\t";
infos += "EtatProcessus: " + processus.getEtat() + "\n\t";
infos += "EtatThread: " + this.etat;
return(infos);
}
// Décrémenter la priorité (pour le PP uniquement)
private void decrementerPriorite(Processus processus)
{
if (executePCA == false)
{
processus.setPriorite();
foreach (Thread thread in processus.getThreads())
{
thread.setPriorite();
updateInfoThread(processus);
}
}
}
// Exécution d'un calcul
private void executerCalcul(Instruction instruction, Thread thread, Processus processus)
{
processus.setEtat(Enums.etatProcessus.Actif);
thread.setEtat(Enums.etatThread.Actif);
instruction.Etat = Enums.etatInstruction.EnCours;
decrementerTempsESBloque();
updateInfoThread(processus);
updateCouleur();
sleep();
instruction.Etat = Enums.etatInstruction.Termine;
updateCouleur();
}
// Trouver l'instruction du processus de la barrière précédante (pour éviter les interblocages)
private int trouverInstructionPrecedante(Processus processus)
{
int instructionPrec = 1;
foreach (KeyValuePair <int, int> kvp in lstBarrieres[lstBarrieres.Count - 1].barriere)
{
if (kvp.Key == processus.getPID())
{
instructionPrec = kvp.Value;
}
}
return(instructionPrec);
}
// Générer un nombre aléatoire entre 1 et le nombre d'instructions du processus
private int genererNbAleatoire(Processus processus)
{
int niemeInstruction = 0;
if (lstBarrieres.Count == 0)
{
niemeInstruction = RandomNumber(1, trouverNbInstructionsProcessus(processus) + 1);
}
else
{
niemeInstruction = RandomNumber(trouverInstructionPrecedante(processus), trouverNbInstructionsProcessus(processus) + 1);
}
return(niemeInstruction);
}
// Exécution d'une E/S
private List <Processus> executerES(Instruction instruction, Thread thread, Processus processus)
{
instruction.Etat = Enums.etatInstruction.EnCours;
processus.setEtat(Enums.etatProcessus.Bloque);
thread.setEtat(Enums.etatThread.Bloque);
updateInfoThread(processus);
updateCouleur();
decrementerTempsESBloque();
sleep();
if (executePCA == true)
{
return(OrderListProcessusPCA(lstProcessus));
}
else
{
return(OrderListProcessusPP(lstProcessus));
}
}
// Supprimer une barrière si elle contenait le processus supprimé
private void supBarriere(Processus processus)
{
bool processusSupprime = false;
foreach (Barriere barriere in lstBarrieres)
{
foreach (KeyValuePair <int, int> kvp in barriere.getBarriere())
{
if (processus.getPID() == kvp.Key)
{
lstBarrieres.Remove(lstBarrieres.Find(cetteBarriere => cetteBarriere.getID() == barriere.getID()));
processusSupprime = true;
break;
}
}
if (processusSupprime == true)
{
break;
}
}
}
// Ajouter le processus quand on clique sur ok
private void btnOk_Click(object sender, EventArgs e)
{
int indiceTID = -1;
foreach (Processus processus in lstProcessus)
{
foreach (Thread thread in processus.getThreads())
{
indiceTID++;
}
}
Processus currentProcessus = new Processus(this.lstProcessus.Count(), this.txtNom.Text, Convert.ToInt32(this.numPriorite.Value), this.numNbInstructCalc.Value, this.numNbInstructES.Value, this.nbThread(), indiceTID);
if (this.checkInputFilled())
{
this.lstProcessus.Add(currentProcessus);
this.Close();
}
else
{
MessageBox.Show("Saisie incorrecte");
}
}
