Posted By

naveenrn on 10/18/13

Tagged

Versions (?)

Last Edited at 10/18/13 06:06am

Statistics

Viewed 693 times

Favorited by 0 user(s)

Related snippets

Bankers Algorithm and Unix Program Scheduling

/ Published in: C++

The Bankers Algorithm Implementation using the process scheduling and UNIX pipes usage

Highlighted TextExpand

/**********************************************************************************************************/
/*Author : Naveen Namashivayam*/
/*Dated  : 26-Sep-2013*/
/*Implementation of Banker's Algorithm using pipes with the SJF/LLF Scheduling*/
/**********************************************************************************************************/

#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <fstream>
#include <iostream>
#include <list>
#include <sstream>
#include <stdio.h>
#include <string>
#include <sys/types.h>
#include <unistd.h>
#include <vector>

using namespace std;

char chars[] = "()-";

int scheduleType;
//variable declaration
int numProcess, numResource, childMember, relDeadLine, totalProcessCount;
vector <int> availableResource;
vector < vector<int> > maxResourceDemand;
vector < vector<string> > processList;
vector < vector<string> > processListBuffer;
vector < vector<int> > processListMain;
vector < vector<int> > allocateResource;
vector <int> needResource;
int sortArray[15][15];
int sortArrayRerun[15][15];
int llfArrange[15][15] ;
vector < vector<string> > finalStatement;
int finalCount=0;

/*******************************************************/
//Function Name : getInputFromFile
//Functionality : To fetch the data from the input file
//                With the data obtained from the input
//                file, the text parsing on the same is 
// 		  completed. 
/*******************************************************/
int getInputFromFile()
{
	//buffer variable declaration
	vector <string> buffVectorA;
	ifstream infile;
	int iBuff = 0, countBuff = 0, intBuff;

//input.txt file availability check
	infile.open("input.txt");
	if (!infile)
	{
		cout << "The Input File is not Open" << endl;
		cin.get();
        exit(1);
	}
	
	//obtaining values from input.txt file
	string tmpStr;
	while ( !infile.eof() )
	{
		std :: getline (infile, tmpStr);
		buffVectorA.push_back(tmpStr);
		countBuff++;
	}

//feeding data to the global variables
        char str[20];
	istringstream ( buffVectorA[0] ) >> numResource; //getting numResource
	istringstream ( buffVectorA[1] ) >> numProcess;  //getting numProcess
	//getting all the availableResource values
	for (iBuff = 2; iBuff < buffVectorA.size(); iBuff++)
	{
        if ( iBuff < numResource + 2 )
           {
		   unsigned pos = buffVectorA[iBuff].find("=");
		   string buffStr = buffVectorA[iBuff].substr (pos);
		   size_t length = buffStr.copy(str, buffStr.length() - 1, 1);
		   str[length] = '\0';
		   istringstream ( str ) >> intBuff;
		   availableResource.push_back(intBuff);
           }   
        else break;
        } 
    
        //getting all the maxResourceDemand value
	const int rowsVector = numProcess;
	const int columnsVector = numResource;
	for ( iBuff = 0; iBuff < buffVectorA.size(); iBuff++ ) 
        {
   	   if ( ( iBuff < ( numProcess * numResource) + 1 ) && ( iBuff >= 2 ) )
           { maxResourceDemand.push_back(vector<int>()); } /* Adding an empty row */
 	}
        for (iBuff = 0; iBuff < buffVectorA.size(); iBuff++)
	{
		if ( ( iBuff < ( numProcess * numResource) + numResource + 2 ) && ( iBuff >= numResource + 2 ) )
		{
           	   unsigned pos = buffVectorA[iBuff].find("=");
		   string buffStr = buffVectorA[iBuff].substr (pos);
		   size_t length = buffStr.copy(str, buffStr.length() - 1, 1);
		   str[length] = '\0';
		   istringstream ( str ) >> intBuff;
		   int tempInt = ((iBuff - 2)  / numResource);
		   maxResourceDemand[tempInt - 1]. push_back(intBuff);
		}
		else if ( iBuff <= numResource + 1 )
		{}
		else break;
	}

//getting all the process values
	int processBuff[10], jBuff, loopBuff = 0;
	string strBuff;
	for ( iBuff = 0; iBuff < buffVectorA.size(); iBuff++ ) 
     	{
   	 if ( ( iBuff > ( ( numProcess * numResource) + numResource + 1 ) ) )
         { 
			strBuff = buffVectorA[iBuff];
			if(strBuff.compare (0, 3, "end") == 0)
			{
				processBuff[loopBuff] = iBuff;
				loopBuff = loopBuff + 1;
			} 
	 }
    	}
	totalProcessCount = ( buffVectorA.size() - ( ( numProcess * numResource) + numResource + 2 + ( numProcess * 2 ) + ( numProcess * 2 )) );
	for ( iBuff = 0; iBuff < totalProcessCount; iBuff++ ) 
    	{
        	processList.push_back( vector<string>() ); // Adding an empty row
    	}
   	countBuff = 0; int loop = 0;
    	string strBuff1, strBuff2, strBuff0;
	for ( iBuff = 0; iBuff < buffVectorA.size(); iBuff++)
	{
		strBuff = buffVectorA[iBuff];
		if( strBuff.compare (0, 7, "process") == 0 )
		    {
    		     strBuff0 = buffVectorA[iBuff];
    		     strBuff1 = buffVectorA[iBuff + 1];
   		     strBuff2 = buffVectorA[iBuff + 2];
            	    }
        
		else if( ( strBuff.compare (0, 7, "request") == 0 ) || (strBuff.compare (0, 7, "release") == 0))
		    {
             		processList[countBuff].push_back(strBuff0); //Process ID
             		processList[countBuff].push_back(strBuff1); //deadline
             		processList[countBuff].push_back(strBuff2); //Computation Time
             		processList[countBuff].push_back(strBuff);  //Request/Releaase Type
		     	countBuff++;
            	    }

else
		    {
			continue;
		    }
    	}

infile.close();
}

/*******************************************************/
//Function Name : inputProcessListParsing
//Functionality : To parse the obtained Process List and 
//                place them in a particular format
//                process_name<sp>deadline<sp>compTime<sp> 
//                process_ID<sp>resource<sp>
//		  The above format is used for parsing 
/*******************************************************/
int inputProcessListParsing()
{
	for (int iBuff = 0; iBuff < totalProcessCount; iBuff++ ) 
    	{
        	processListMain.push_back( vector<int>() ); // Adding an empty row
    	}

int intBuff;
	string strBuffer;
	char str[20];
        for (int iBuff = 0; iBuff < totalProcessCount - 1; iBuff++)
	{
        for (int jBuff = 0; jBuff < 4; jBuff++)
	{
            strBuffer = processList[iBuff][jBuff]; 
            switch(jBuff)
            {
            case 0:
            {
                             //processing the process ID and retrieving values accordingly
			     if( strBuffer.compare (0, 7, "process") == 0 )
			     {
				     unsigned pos = strBuffer.find("_");
				     string buffStr = strBuffer.substr (pos);
				     size_t length = buffStr.copy(str, buffStr.length() - 1, 1);
				     str[length] = '\0';
				     istringstream ( str ) >> intBuff;
				     processListMain[iBuff].push_back(intBuff);
		             } 
			     break;
            }

case 1:
            {
			     istringstream ( strBuffer ) >> intBuff; 
			     processListMain[iBuff].push_back(intBuff);
                             break;
            }   
            
            case 2:
            {
			     istringstream ( strBuffer ) >> intBuff;
			     processListMain[iBuff].push_back(intBuff);
                   	     break;
            }
             
            case 3:
            {
			     //processing if the obtained list is a request
			     if( strBuffer.compare (0, 7, "request") == 0 )
			     {
				     //cout << "1" << "\t";//printing request value as 1
				     processListMain[iBuff].push_back(1);
                      		     istringstream ss (strBuffer);
                      		     string token;
                                     while(getline(ss, token, ','))
                       		     {
                      			if ( token.compare (0, 7, "request") == 0 )
                       			{
                          			unsigned pos = token.find("(");
                          			string buffStr = token.substr (pos);
				          	size_t length = buffStr.copy(str, buffStr.length() - 1, 1);
				          	str[length] = '\0';
				          	istringstream ( str ) >> intBuff;
				          	//cout << intBuff << "\t";
						processListMain[iBuff].push_back(intBuff);
                      			}
                      			else
                      			{
			              		string str1;
			              		str1 = token;
			              		for ( unsigned int i = 0; i < strlen(chars); ++i )
			                  		str1.erase( remove( str1.begin(), str1.end(), chars[i] ), str1.end());
                          			istringstream ( str1 ) >> intBuff;
						//cout << str1 << "\t";
						processListMain[iBuff].push_back(intBuff);
                      			}
                     		     }
			     }
			     //processing if the obtained list is a release
			     if( strBuffer.compare (0, 7, "release") == 0 )
			     {
				     //cout << "0" << "\t";//printing request value as 1
				     processListMain[iBuff].push_back(0);
                     		     istringstream ss (strBuffer);
                     		     string token;
                     		     while(getline(ss, token, ','))
                     		     {
                       			 if ( token.compare (0, 7, "release") == 0 )
                        		 {
                           			unsigned pos = token.find("(");
                           			string buffStr = token.substr (pos);
				           	size_t length = buffStr.copy(str, buffStr.length() - 1, 1);
				           	str[length] = '\0';
				          	istringstream ( str ) >> intBuff;
				           	//cout << intBuff << "\t";
						processListMain[iBuff].push_back(intBuff);
                        		 }
                        		 else
                        		 {
			                	string str1;
			                	str1 = token;
			                	for ( unsigned int i = 0; i < strlen(chars); ++i )
			                	str1.erase( remove( str1.begin(), str1.end(), chars[i] ), str1.end());
                            			//cout << str1 << "\t";
						istringstream ( str1 ) >> intBuff;
						processListMain[iBuff].push_back(intBuff);
                        		 }	
                      		     }	
                 	     }
			     break ;
	    }
            }
	}
        cout << endl;
    }
}

/*******************************************************/
//Function Name : initAllocatedResource
//Functionality : Initializing the allocated resource 
//				  values 
/*******************************************************/
int initAllocatedResource()
{
	int temp = 0;
	for (int iBuff = 0; iBuff < numProcess; iBuff++ ) 
    	{
        	allocateResource.push_back( vector<int>() ); // Adding an empty row
    	}
	for (int iBuff = 0; iBuff < numProcess; iBuff++ ) 
		for (int jBuff = 0; jBuff < numResource; jBuff++ ) 
		{
        	allocateResource[iBuff].push_back(temp);
    		}
}

/*******************************************************/
//Function Name : initFinalStatement
//Functionality : Initializing the final statement
//                                values
/*******************************************************/
int initFinalStatement()
{
        int temp = 0;
        for (int iBuff = 0; iBuff < (totalProcessCount + totalProcessCount); iBuff++ )
        {
                finalStatement.push_back( vector<string>() ); // Adding an empty row
        }
}

/*******************************************************/
//Function Name : ShortJobFirstScheduling
//Functionality : The Process Requests and releases are 
//	          sorted as per the Shortest Path First
//	          Scheduling
/*******************************************************/
int ShortJobFirstScheduling()
{
 vector < vector<string> > SJFBuffer;
 int intBuff;
 vector < string > strBuff;
 char str[20];
 int count = 0;

for ( int jBuff = 0; jBuff < totalProcessCount - 1; jBuff++)
 {
	 for ( int iBuff = 0; iBuff < totalProcessCount - 1; iBuff++)
	 {
		if ( ( processList[iBuff][2] > processList[iBuff + 1][2] ) && ( iBuff != totalProcessCount ) )
	{
		strBuff = processList[iBuff];
		processList[iBuff] = processList[iBuff + 1];
		processList[iBuff + 1] = strBuff;
	}
	else
	{
		count++;
		if( count == totalProcessCount )
			break;
	}
 }
 }

int temp1 = 0;
 int temp2 = 0;
 for(int i=0; i < totalProcessCount; i++)
	{ 
	cout << processList[i][0] << endl;
	if((i+1) != totalProcessCount ) 
	 { 
	  if(processList[i][0] != processList[i+1][0]) 
	  {  
	   sortArray[temp1][temp2] = i;
	   temp2=0; 
           temp1++;
	  }
	  else
	  {
	   sortArray[temp1][temp2] = i;
 	   temp2++; 
	  } 
	 }
	}
}

/*******************************************************/
//Function Name : llfSort
//Functionality : sorting as per LLF and sending the pointer
/*******************************************************/
int llfSort()
{
 int strBuff;
 int count = 0;
 for ( int jBuff = 0; jBuff < numProcess + 1; jBuff++)
 {
         for ( int iBuff = 0; iBuff < numProcess; iBuff++)
         {
                if ( ( llfArrange[iBuff][2] > llfArrange[iBuff+1][2]) && ( iBuff != numProcess ) )
      		  {
			for(int i = 0; i < 5; i++)
			{
               		 strBuff = llfArrange[iBuff][i];
	                 llfArrange[iBuff][i] = llfArrange[iBuff + 1][i];
         	         llfArrange[iBuff + 1][i] = strBuff;
			}
        	  }
	        else
        	  {
                	 count++;
	                 if( count == numProcess )
         	               break;
        	  }
 	}	
 }

}

/*******************************************************/
//Function Name : LeastLaxityFirstScheduling
//Functionality : The Process Requests and releases are
//                sorted as per the Least Laxity First
//                Scheduling
/*******************************************************/
int LeastLaxityFirstScheduling()
{
 vector < vector<string> > SJFBuffer;
 int intBuff;
 vector < string > strBuff;
 char str[20];
 int count = 0;

for ( int jBuff = 0; jBuff < totalProcessCount - 1; jBuff++)
 {
         for ( int iBuff = 0; iBuff < totalProcessCount - 1; iBuff++)
         {
                if ( ( processList[iBuff][2] > processList[iBuff + 1][2] ) && ( iBuff != totalProcessCount ) )
        {
                strBuff = processList[iBuff];
                processList[iBuff] = processList[iBuff + 1];
                processList[iBuff + 1] = strBuff;
        }
        else
        {
                count++;
                if( count == totalProcessCount )
                        break;
        }
 }
 }

int temp1 = 0;
 int temp2 = 0;
 for(int i=0; i < totalProcessCount; i++)
        {
        cout << processList[i][0] << endl;
        if((i+1) != totalProcessCount )
         {
          if(processList[i][0] != processList[i+1][0])
          {
           sortArray[temp1][temp2] = i;
           temp2=0;
           temp1++;
          }
          else
          {
           sortArray[temp1][temp2] = i;
           temp2++;
          }
         }
        }

int temp11, temp12, temp13;
 for(int i=0; i < numProcess; i++)
 {
	temp11 = sortArray[i][0];
	istringstream ( processList[temp11][1] ) >> temp12;
	istringstream ( processList[temp11][2] ) >> temp13;
	::llfArrange[i][0] = temp12;
	::llfArrange[i][1] = temp13;
	::llfArrange[i][2] = temp12 - temp13;
	::llfArrange[i][3] = 0;
	::llfArrange[i][4] = i;
 }
 
}

/*******************************************************/
//Function Name : outputPrint
//Functionality : To print the contents of the output file
//                Number of Resource, Number of Process
//                Available Resource, Process List are all  
// 				  displayed.
/*******************************************************/
int outputPrint()
{
    cout << "*****************************************" << endl;
    cout << "****INPUT DATA SUMMARY FROM input.txt****" << endl;
    cout << "*****************************************" << endl;
	cout << "Number of Resource : " << numResource << endl; 
	cout << "Number of Process : " << numProcess << endl;
	cout << "Available Resource" << endl;
    for (vector<int>::iterator it = availableResource.begin(); it != availableResource.end(); ++it)
     std::cout << *it << " ";
	cout << endl;
    cout << "*********************************************************" << endl;
    cout << "maximum resource" << endl;
    cout << "*********************************************************" << endl;
    for (int iBuff = 0; iBuff < numProcess; iBuff++)
	{
        for (int jBuff = 0; jBuff < numResource; jBuff++)
	        cout << maxResourceDemand[iBuff][jBuff] << " ";
        cout << endl;
    }
    cout << "*********************************************************" << endl;
    cout << "initial allocated resource" << endl;
    cout << "*********************************************************" << endl;
    for (int iBuff = 0; iBuff < numProcess; iBuff++)
	{
        for (int jBuff = 0; jBuff < numResource; jBuff++)
	        cout << allocateResource[iBuff][jBuff] << " ";
        cout << endl;
    }
    cout << "**********************************************************" << endl;
    cout << "Request and Release Scheduled Run" << endl;
    cout << "**********************************************************" << endl;

}
         
/*******************************************************/
//Function Name : reqAllocation
//Functionality : As the safety check on the request is
//                made and the return value obtained is
//                safe, we can allocate the resource for
//                the request
/******************************************************/
int reqAllocation(int tokenPt)
{
        int temp, i, temp1;
        temp1 = processListMain[tokenPt][0];
        for (i = 0; i < numResource; i++)
        {
          temp = ::allocateResource[temp1-1][i];
          ::allocateResource[temp1-1][i] = temp + processListMain[tokenPt][i+4];
        }

for( i = 0; i < numResource; i++)
        {
          temp = ::availableResource[i];
          ::availableResource[i] = temp - processListMain[tokenPt][i+4];
        }
        cout << "Available Resource" << endl;
        for (vector<int>::iterator it = ::availableResource.begin(); it != ::availableResource.end(); ++it)
                std::cout << *it << " ";
        cout << endl;

cout << "Allocated resource" << endl;
        for (int iBuff = 0; iBuff < numProcess; iBuff++)
               {for (int jBuff = 0; jBuff < numResource; jBuff++)
                         cout << ::allocateResource[iBuff][jBuff] << " ";
                cout << endl;}
	
	for (i = 0; i < totalProcessCount - 1; i++)
		processListMain[i][1] = processListMain[i][1] - processListMain[i][2];

return 0;
}

/******************************************************/
//Function Name : reqModification
//Functionality : As the safety check on the request is
//                failed and hence the resource is kept
//                in que and the modifications are made
//                on the computation time
/******************************************************/
int reqModification(int tokenPt)
{
        for (int i = 0; i < totalProcessCount - 1; i++)
                processListMain[i][1] = processListMain[i][1] - 1;
}

/*******************************************************/
//Function Name : reqRelease
//Functionality : When there is a release request made,
//                the corresponding Process gets released
/*******************************************************/
int reqRelease(int tokenPt)
{
        int temp, i, temp1;
        temp1 = processListMain[tokenPt][0];
        for (i = 0; i < numResource; i++)
        {
          temp = ::allocateResource[temp1-1][i];
          if(temp > processListMain[tokenPt][i+4]) { ::allocateResource[temp1-1][i] = temp - processListMain[tokenPt][i+4];}
          else { ::allocateResource[temp1-1][i] = processListMain[tokenPt][i+4] - temp; }
	}

for( i = 0; i < numResource; i++)
        {
          temp = ::availableResource[i];
	  ::availableResource[i] = processListMain[tokenPt][i+4] + temp;
	}
        cout << "Available Resource" << endl;
        for (vector<int>::iterator it = ::availableResource.begin(); it != ::availableResource.end(); ++it)
                std::cout << *it << " ";
        cout << endl;

for (i = 0; i < totalProcessCount - 1; i++)
                processListMain[i][1] = processListMain[i][1] - 1;

return 0;
}

/*******************************************************/
//Function Name : bankersAlgorithmCheck
//Functionality : To check and verify the deadlock safety
//		  for the requested process through the 
//		  Bankers Algorithm
/*******************************************************/
int bankersAlgorithmCheck ( int location )
{
	int pointValue = location;
	int maxAllocated[10][10] = {0};
	int allocResource[10][10] = {0};
	int needlResource[10][10] = {0};
	int availResourceVector[10] = {0};
	int requestResourceVector[10] = {0};

cout << "******************************" << endl;
	cout << processList[pointValue][0] << endl; finalStatement[::finalCount].push_back(processList[pointValue][0]);
	cout << processList[pointValue][3] << endl; finalStatement[::finalCount].push_back(processList[pointValue][3]);

//Verifying Request or Release
	if ( processListMain[pointValue][3] == 0 )
		{ finalStatement[::finalCount].push_back("Release Request : Released"); return 2; }

//Feeding maximum resource table
	for(int i = 0; i < numResource; i++)
		for(int j = 0; j < numProcess; j++)
		    maxAllocated[i][j] = maxResourceDemand[i][j];
	
	//Feeding allocated resource table
	for(int i = 0; i < numResource; i++)
		for(int j = 0; j < numProcess;j ++)
			allocResource[i][j] = allocateResource[i][j];
	
	//Calculating the needResource table from the maxAllocated and allocResource
	for(int i = 0; i < numResource; i++)
		for(int j = 0; j < numProcess; j++)
			needlResource[i][j] = maxAllocated[i][j] - allocResource[i][j];
	
	//Feeding the available Resource vector
        for(int i = 0; i < numResource; i++)
        	availResourceVector[i] = availableResource[i];

//printf( "\nEnter request vector \n");
    	for(int i = 0; i < numResource; i++)
    		requestResourceVector[i] = processListMain[pointValue][i + 4];
		
	for(int i = 0; i < numResource; i++)
    	{
        	if(requestResourceVector[i] > availResourceVector[i])
		{
            		puts("Error : Available Resource is less than Request");
			finalStatement[::finalCount].push_back("Less Available Resource : Queued");
			return 3;
		}	
    	}

//safetyChecking
	for(int i = 0; i < numResource; i++)
		{
			availResourceVector[i] = availResourceVector[i] - requestResourceVector[i];
		}
	int counter = 10;
	bool finish[5] = { false };
	while( counter-- )
	{
    		for(int i = 0; i < (numResource - 1); i++)
     		{ 
			int flag = false;
			if ( finish[i] )
			continue;
			for ( int j = 0; j < (numResource - 1); j++)
        		{
              			flag=true;
              			if( availResourceVector[j] < needlResource[i][j] )
              			{
					flag=false;
					break;
              			}
        		}
        	finish[i] = true;
        	if( finish[i] == true )
        	{
          		for( int l = 0; l < (numResource - 1); l++)
                        availResourceVector[l] += allocResource[i][l];
        	}
    		}	
	}

for(int i = 0; i < (numResource - 1); i++)
		if(finish[i]==false)
		{
		    	finalStatement[::finalCount].push_back("Safety Check : Unsafe - Queued");
			return 1;
		}
	finalStatement[::finalCount].push_back("Safety Check : Safe - Request Processed");
	return 0;
}

/*******************************************************/
//Function Name : createPipe
//Functionality : To create Pipes and the child process 
//		  calls the Bankers Algorithm, while the 
//		  parent process based on the result 
//		  allocates the resource or misses
//		  deadline
/*******************************************************/
int createPipe(int iBuff)
{
	char string1[] = "The Request is in Safe State. The Resources are allocated as follows";
  	char string2[] = "The Request is Not in Safe State";
  	char string3[] = "The Resources are Released Successfully and the resources are available as shown below";
  	char string4[] = "DeadLine Missed";
  	int PFState; 
	
	int i;
	i = iBuff;
	int n;
	int status, pid, pipefds[2];

status = pipe(pipefds);
	
	if (status == -1)
       	{
               perror("Trouble");
               exit(1);
       	}

pid = fork();
       	if (pid == -1)
       	{
               perror("Trouble");
               exit(2);
       	}
	
	else if (pid == 0)//child process
	{
		close(pipefds[0]);//closing child process to write
		write(pipefds[1], &i, sizeof(i));//writing in child process
		close(pipefds[1]);
		exit(0);
		
	}
	else//parent process
	{
		close(pipefds[1]);
		read(pipefds[0], &n, sizeof(n));//reading in parent process
		PFState = bankersAlgorithmCheck(n);//bankers algorithm check in parent process
                if ( PFState==0 )
                { cout << string1 << endl; reqAllocation(i); }
                if ( PFState==1 )
                { cout << string2 << endl; reqModification(i); }
                if ( PFState==2 )		
                { cout << string3 << endl; reqRelease(i); }
                if ( PFState==3)
		{
	  	   int cBuff=0, dBuff=0;
		   for(int iB=1; iB < 15; iB++)
                    for(int jB=1; jB < 15; jB++)
                     {
                      if( (sortArrayRerun[iB][jB] == 0) )
                       {
                        cBuff = iB; dBuff = jB;break;
                       }if( (cBuff != 0) && (dBuff != 0) ){break;} else {continue;}
                     }
	 	   sortArrayRerun[cBuff][dBuff] = i;
		}
		if ( PFState==4 )
                { cout << string4 << endl; }
		sleep(1);
		close(pipefds[0]);//closing parent process
	}
	return PFState;
}

/*******************************************************/
//Function Name : releaseAll
//Functionality : Releasing all the allocated vlues
/*******************************************************/
int finalOutputResult()
{
	system("clear");
	cout << "*****************************************************" << endl;
	cout << "******************   Final Result *******************" << endl;
	cout << "*****************************************************" << endl;
	cout << "AVAILABLE RESOURCE" << endl;
        for (vector<int>::iterator it = ::availableResource.begin(); it != ::availableResource.end(); ++it)
                std::cout << *it << " ";
        cout << endl;
	cout << "*****************************************************" << endl;
        cout << "ALLOCATED RESOURCE" << endl;
        for (int iBuff = 0; iBuff < numProcess; iBuff++)
               {for (int jBuff = 0; jBuff < numResource; jBuff++)
                         cout << ::allocateResource[iBuff][jBuff] << " ";
                cout << endl;}
	cout << "*****************************************************" << endl;
	if(scheduleType == 1) { cout << "SCHEDULING TYPE    : Short Job First" << endl; }
	else { cout << "SCHEDULING TYPE     : Least Laxity First" << endl; }
	cout << "NUMBER OF PROCESS  : " << numProcess << endl;
	cout << "NUMBER OF RESOURCE : " << numResource << endl; 
	cin.get();
	cout << "The requests and releases are scheduled in the following order" << endl;
	for (int iBuff = 0; iBuff < (totalProcessCount+totalProcessCount); iBuff++)
         {
	  if(iBuff != finalCount-1)
          {cout << endl;
	   cout  << iBuff+1 ;
	   cout << finalStatement[iBuff][0] ;
	   cout << finalStatement[iBuff][1] << endl;
	   cout << finalStatement[iBuff][2] << endl;}
	  else
	   break;
         }
}

/*******************************************************/
//Function Name : llfArrangement()
//Functionality : calculating relative deadlline and 
//		  sending back the location pointer
/*******************************************************/
int llfArrangement()
{
 int strBuff;
 int count = 0;
 for ( int jBuff = 0; jBuff < numProcess + 1; jBuff++)
 {
         for ( int iBuff = 0; iBuff < numProcess; iBuff++)
         {
                if ( ( llfArrange[iBuff][2] > llfArrange[iBuff+1][2]) && ( iBuff != numProcess ) )
                  {
                        for(int i = 0; i < 5; i++)
                        {
                         strBuff = llfArrange[iBuff][i];
                         llfArrange[iBuff][i] = llfArrange[iBuff + 1][i];
                         llfArrange[iBuff + 1][i] = strBuff;
                        }
                  }
                else
                  {
                         count++;
                         if( count == numProcess )
                               break;
                  }
        }
 }

}

/*******************************************************/
//Function Name : main
//Functionality : The program starts here and all the fucntion
//                calls are done. 
/*******************************************************/
/*******************************************************/
int main()
{
 int schType;
 getInputFromFile();
 system("clear");
 cout << "***************************************************************" << endl;
 cout << "******    IMPLEMENTING BANKER'S ALGORITHM USING PIPES    ******" << endl;
 cout << "******       SCHEDULING  PROCESSES USING SJF & LLF       ******" << endl;
 cout << "***************************************************************" << endl;
 cout << "Feed the SCHEDULING TYPE" << endl; 
 cout << "1. SJF" << endl << "2. LLF" << endl;
 cin >> schType;
 ::scheduleType = schType;
 switch(schType)
	 {
		 case 1:
			 {
			 ShortJobFirstScheduling();//scheduling the process
			 inputProcessListParsing();//text parsing and passing the necessary values
			 initAllocatedResource();//initializing the allocated Resource - Alloc
			 initFinalStatement();//initializing the final statement vector
			 system("clear");//clearing system for user reference
			 outputPrint();//output display
			 for(int i=0; i < 15; i++)
    			 {
     			  for(int j=0; j < 15; j++)
     			  {
        		  if( (sortArray[j][i] != 0) || ( (i==0) && (j==0) ) )
         		  {         
			   int iBuff = sortArray[j][i];
			   createPipe(iBuff);//creating pipes and calling Banker's Algorithm from the Parent Process
			   ::finalCount++;
			  }
			  }
		         }
                         for(int i=0; i < 15; i++)
                         {
                          for(int j=0; j < 15; j++)
                          {
                          if( (sortArrayRerun[j][i] != 0) || ( (i==0) && (j==0) ) )
                          {
                           int iBuff = sortArrayRerun[j][i];
                           createPipe(iBuff);//creating pipes and calling Banker's Algorithm from the Parent Process
                           ::finalCount++;
			  }
                          }
                         }
			 releaseAll();
			 finalOutputResult();
			 break;
			 }
		 case 2:
			 {
			 int maxResourceValue = 0;
			 LeastLaxityFirstScheduling();//scheduling the process
		   	 inputProcessListParsing();//text parsing and passing the necessary values
                         initAllocatedResource();//initializing the allocated Resource - Alloc
			 initFinalStatement();//initializing the final statement vector
                         system("clear");//clearing system for user reference
                         outputPrint();//output display
                         llfSort();//sorting as per the llf and identifing the initial pointer and deadline miss
			 for(int i=0; i < 15; i++)
			 {
			  for(int j=0; j < 15; j++)
			  {
		           if ( sortArray[i][j] != 0 )
			   {
			    if ( maxResourceValue < j ) { maxResourceValue++; }
			   }
			  }
			 }
			 for(int i=0; i < maxResourceValue; i++)
			 {
			  for(int j=1; j < numProcess+1; j++)
			  {
			   if(llfArrange[j][1] != 0)//computation time not less than 0
			   {
			    if((llfArrange[j][0] != 0) && (llfArrange[j][0] >0) )//deadline not less than 0
			    {
				int iBuff = sortArray[ llfArrange[j][4] ] [ llfArrange[j][3] ]; cout <<iBuff << endl;
				int x = createPipe(iBuff);//creating Pipe and calling Banker's Algorithm from the parent process
			        for(int iBuffer = 1; iBuffer < numProcess + 1; iBuffer++)
				{
				 if ( (x == 0 ) || ( x == 1) || ( x == 2) )
					{
					 if ( iBuffer == j ) { llfArrange[iBuffer][3]++;}//incrementing pointer
					 llfArrange[iBuffer][1]--;//decreasing computation time
					 llfArrange[iBuffer][0]--;//decreasing deadline
					}
				 if ( (x==3) )
					{
				         if ( iBuffer == j ) { llfArrange[iBuffer][3]++;}//incrementing pointer
					 llfArrange[iBuffer][0]--;//decreasing deadline alone
					 llfArrangement();
					}
				}
				//for(int k=1; k <numProcess+1; k++) cout <<llfArrange[k][0]<<llfArrange[k][1]<<llfArrange[k][2]<<endl;
				::finalCount++;
			    }
			    else
			    {
				int pointValue = sortArray[llfArrange[j][4]][llfArrange[j][3]];
			        cout << "******************************" << endl;
			        cout << processList[pointValue][0] << endl; finalStatement[::finalCount].push_back(processList[pointValue][0]);
			        cout << processList[pointValue][3] << endl; finalStatement[::finalCount].push_back(processList[pointValue][3]);
				cout << "Deadline Missed" << endl;
				::finalStatement[::finalCount].push_back("Deadline Missed");
                                for(int iBuffer = 1; iBuffer < numProcess + 1; iBuffer++)
                                {
                                         if ( iBuffer == j ) { llfArrange[iBuffer][3]++;}//incrementing pointer
                                }
                                //for(int k=1; k <numProcess+1; k++) cout <<llfArrange[k][0]<<llfArrange[k][1]<<llfArrange[k][2]<<endl;
				::finalCount++;llfArrangement();
			    }
			   }
			  }
			 }
                         releaseAll();
			 finalOutputResult();
			 break;
			 }
		 default:
			 {
			 cout << "Invalid Entry" << endl;
			 }
	 }
 cin.get();
 return 0;
}

Report this snippet Tweet

Comments

Subscribe to comments

Comment:

You need to login to post a comment.