/* Author : Abraham Cabrera

* Date : 11/14/2010
*Purpose : Banker Algorithm for class: SICI-4029-LM1
*/
#include <iostream>
#include <iomanip>
#include <fstream>
#include <windows.h>
using namespace std;
//Global Structures.
struct CPU {
int resrceCapcty0,
resrceCapcty1,
resrceCapcty2,
resrceCapcty3,
resrceCapcty4;
};
struct PROCESS {
char pid;
int resource0,
resource1,
resource2,
resource3,
resource4;
int availableRsr0,
availableRsr1,
availableRsr2,
availableRsr3,
availableRsr4;
bool status;
};
//Global Constant.
const int MAX_PROCESSES = 4;
//Prototypes.
bool OpenFile(fstream &);
CPU * GetCpuSpecs(fstream &);
PROCESS * GetProcess(fstream &);
bool ValidateProcess(PROCESS *, CPU *);
void FreeProcesses(PROCESS *[], const int);
void FreeProcess(PROCESS *);
void DistributeMemory(PROCESS *[], CPU *, const int, int &iteration);
void ShowMemManagement(PROCESS *[],CPU *, CPU *, const int, const int);
CPU *CreateCpu(CPU *);
void SetProcessStatus(PROCESS *);
int main() {
//Local Variables
CPU *mainCpu;
PROCESS *processList[MAX_PROCESSES], *tmpProcess = 0x00;
fstream inFile;
int processAmount = 0, processSize = 0, numRejected = 0, iterations= 0;
bool ready = false;
while(!ready)
ready = OpenFile(inFile);
mainCpu = GetCpuSpecs(inFile);
 tmpProcess = GetProcess(inFile);
ready = ValidateProcess(tmpProcess, mainCpu);
while(!inFile.eof()) {
if(ready) {
processList[processSize++] = tmpProcess;
}
else {
FreeProcess(tmpProcess);
numRejected++;
}
if(processSize == MAX_PROCESSES) {
DistributeMemory(processList, mainCpu, processSize, iter
ations);
FreeProcesses(processList, processSize);
processSize = processSize % MAX_PROCESSES;
}
processAmount++;
tmpProcess = GetProcess(inFile);
ready = ValidateProcess(tmpProcess, mainCpu);
}
if(processSize > 0 && processSize < MAX_PROCESSES)
DistributeMemory(processList, mainCpu, processSize, iterations);
FreeProcesses(processList, processSize); //Releaseing the memory that wa
s separated for all the left over processes cpu.
delete mainCpu; //Releaseing the memory that was separated for the main
cpu.
inFile.close(); //Closing file
cout << "\n Total processes rejected: " << numRejected << endl;
cout << "\n Press enter key to continue...";
while(cin.get() != '\n');
cin.get();
return 0;
}
bool OpenFile(fstream &input) {
//Local variables
char fileName[20];
cout << "Please enter the name of the file: ";
cin >> fileName;
input.open(fileName);
if(!input){
cout << "Error opening file.! Please try again.\n\t";
return false;
}
else
return true;
}
CPU * GetCpuSpecs(fstream &input) {
CPU * newCpu = new CPU;
char tmp;
 input >> newCpu->resrceCapcty0
>> tmp
>> newCpu->resrceCapcty1
>> tmp
>> newCpu->resrceCapcty2
>> tmp
>> newCpu->resrceCapcty3
>> tmp
>> newCpu->resrceCapcty4;
return newCpu;
}
PROCESS * GetProcess(fstream &input) {
//Local Variables
PROCESS *newProcess = new PROCESS;
char tmp;
input >> newProcess->pid
>> tmp
>> newProcess->resource0
>> tmp
>> newProcess->resource1
>> tmp
>> newProcess->resource2
>> tmp
>> newProcess->resource3
>> tmp
>> newProcess->resource4;
newProcess->availableRsr0 = 0;
newProcess->availableRsr1 = 0;
newProcess->availableRsr2 = 0;
newProcess->availableRsr3 = 0;
newProcess->availableRsr4 = 0;
newProcess->status = true;
return newProcess;
}
void FreeProcesses(PROCESS *procList[], const int amount) {
for(int i = 0; i < amount; i++)
FreeProcess(*(procList + i));//Releaseing the memory that was se
parated for the process.
}
void FreeProcess(PROCESS * aProc) {
delete aProc;
aProc = 0x00;
}
bool ValidateProcess(PROCESS *self, CPU *mainCpu) {
if(self->resource0 > mainCpu->resrceCapcty0)
return false;
else {
if(self->resource1 > mainCpu->resrceCapcty1)
return false;
else {
if(self->resource2 > mainCpu->resrceCapcty2)
return false;
else {
if(self->resource3 > mainCpu->resrceCapcty3)
return false;
else {
 if(self->resource4 > mainCpu->resrceCapc
ty4)
return false;
else
return true;
}
}
}
}
}
void DistributeMemory(PROCESS *procList[], CPU *mainCpu, const int size, int &it
erations) {
CPU *aCPU;
aCPU = CreateCpu(mainCpu);
int cntr = 0;
ShowMemManagement(procList, mainCpu, aCPU, size, iterations);
for(int i = 0; i < size; i++) {
if(procList[i]->status) {
if(procList[i]->resource0 <= aCPU->resrceCapcty0) {
aCPU->resrceCapcty0 = aCPU->resrceCapcty0 - proc
List[i]->resource0;
procList[i]->availableRsr0 = procList[i]->resour
ce0;
}
if(procList[i]->resource1 <= aCPU->resrceCapcty1){
aCPU->resrceCapcty1 = aCPU->resrceCapcty1 - proc
List[i]->resource1;
procList[i]->availableRsr1 = procList[i]->resour
ce1;
}
if(procList[i]->resource2 <= aCPU->resrceCapcty2){
aCPU->resrceCapcty2 = aCPU->resrceCapcty2 - proc
List[i]->resource2;
procList[i]->availableRsr2 = procList[i]->resour
ce2;
}
if(procList[i]->resource3 <= aCPU->resrceCapcty3){
aCPU->resrceCapcty3 = aCPU->resrceCapcty3 - proc
List[i]->resource3;
procList[i]->availableRsr3 = procList[i]->resour
ce3;
}
if(procList[i]->resource4 <= aCPU->resrceCapcty4){
aCPU->resrceCapcty4 = aCPU->resrceCapcty4 - proc
List[i]->resource4;
procList[i]->availableRsr4 = procList[i]->resour
ce4;
};
SetProcessStatus(procList[i]);
ShowMemManagement(procList, mainCpu, aCPU, size, iterati
ons);
}
if(i == (size-1)) {
for(int k= 0; k < size; k++)
if(!procList[k]->status)
cntr++;
if(cntr != size) {
 i = (i % (size-1)) -1;
delete aCPU;
aCPU = CreateCpu(mainCpu);
cntr = 0;
iterations++;
}
}
}
delete aCPU;
}
void ShowMemManagement(PROCESS *procList[],CPU *mainCpu, CPU *aCpu, const int si
ze, const int iterations) {
system("cls");
cout << endl
<< setw(54) << "Algoritmo el Banquero\n"
<< setw(54) << "---------------------\n" << endl;
cout << setw (14) << "CPU Memory: " << setw(4)
<< mainCpu->resrceCapcty0 << ' '
<< mainCpu->resrceCapcty1 << ' '
<< mainCpu->resrceCapcty2 << ' '
<< mainCpu->resrceCapcty3 << ' '
<< mainCpu->resrceCapcty4 << endl;
cout << setw (17) << "Available Mem: " << aCpu->resrceCapcty0 << ' '
<< aCpu->resrceCapcty1 << ' '
<< aCpu->resrceCapcty2 << ' '
<< aCpu->resrceCapcty3 << ' '
<< aCpu->resrceCapcty4 << endl << endl;
cout << setw(30) << "Original Memory" << setw(40) << "Allocated Memory"
<< endl;
cout << setw(30) << "---------------" << setw(40) << "----------------"
<< endl << endl;
cout << setw(5) << "PID" << setw(7) << "MEM 0" << setw(7) << "MEM 1" <<
setw(7) << "MEM 2" << setw(7) << "MEM 3" << setw(7) << "MEM 4" << setw(7) << "S
tatus"
<< setw(6) << "MEM 0" << setw(6) << "MEM 1" << setw(6) << "MEM 2" << se
tw(6) << "MEM 3" << setw(6) << "MEM 4" << endl;
cout << setw(5) << "---" << setw(7) << "-----" << setw(7) << "-----" <<
setw(7) << "-----" << setw(7) << "-----" << setw(7) << "------"<< setw(7) << "-
-----"
<< setw(6) << "-----" << setw(6) << "-----" << setw(6) << "-----" << se
tw(6) << "-----" << setw(6) << "-----" << endl;
for(int i = 0; i < size; i++) {
cout << setw(5) << procList[i]->pid << setw(7) << procList[i]->r
esource0 << setw(7)
<< procList[i]->resource1 << setw(7) << procList[i]->re
source2 << setw(7)
<< procList[i]->resource3 << setw(7) << procList[i]->re
source4 << setw(7);

if(procList[i]->status)
cout << "Ready" << setw(6);
else
cout << "Exit" << setw(6);
 cout << procList[i]->availableRsr0 << setw(6) << procLis
t[i]->availableRsr1 << setw(6)
<< procList[i]->availableRsr2 << setw(6) << pro
cList[i]->availableRsr3 << setw(6)
<< procList[i]->availableRsr4 << endl;
}
cout << endl << setw(14) << "Iterations: " << iterations << endl;
Sleep(2000);
}
CPU *CreateCpu(CPU *mainCpu) {
//Local Variables
CPU *aCPU;
aCPU = new CPU;
aCPU->resrceCapcty0 = mainCpu->resrceCapcty0;
aCPU->resrceCapcty1 = mainCpu->resrceCapcty1;
aCPU->resrceCapcty2 = mainCpu->resrceCapcty2;
aCPU->resrceCapcty3 = mainCpu->resrceCapcty3;
aCPU->resrceCapcty4 = mainCpu->resrceCapcty4;
return aCPU;
}
void SetProcessStatus(PROCESS * aProc) {
if(aProc->resource0 == aProc->availableRsr0) {
if(aProc->resource1 == aProc->availableRsr1){
if(aProc->resource2 == aProc->availableRsr2) {
if(aProc->resource3 == aProc->availableRsr3){
if(aProc->resource4 == aProc->availableR
sr4) {
aProc->status = false;
}
}
}
}
}
}