Advertisement
Dark_Shard

FCFS_Res

Jul 17th, 2019
90
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 9.60 KB | None | 0 0
  1. #include<iostream>
  2.  
  3. using namespace std;
  4.  
  5. int main()
  6. {
  7.     int cols = 8;
  8.     int row = 5;
  9.    
  10.     int counter = 0;
  11.     int arraycounter = 0;
  12.    
  13.     int idle = 0;
  14.     int idle_counter = 0  ;
  15.    
  16.     int start_time = 0;
  17.     int end_time = 0;
  18.     int total_time = 0;
  19.     int final_time = 0;
  20.    
  21.    
  22.     int average_wt = 0;
  23.     int average_bt = 0;
  24.     int average_tt = 0 ;
  25.     int average_at = 0;
  26.    
  27.    
  28.     int temp_var = 0;
  29.     cout << "\t\t\t\tFCFS SCHEDULING"  <<endl;
  30.     cout << "-------------------------------------------------------------------------------";
  31.     cout << "\nInput number of processes" << endl;
  32.     cin >> row;
  33.            
  34.     while(cin.fail())
  35.             {
  36.                 cin.clear();
  37.                 cin.ignore(512, '\n');
  38.                 cout << "Input error " << endl;
  39.                 cout << "Input number of processes" << endl;
  40.                 cin >> row;
  41.             }  
  42.            
  43.    
  44.    
  45.     while(row>10 || row <= 0)
  46.     {
  47.         cout << "Processes cannot be more than 10 or less than 1. Please input another value." << endl;
  48.         cin >> row;
  49.         while(cin.fail())
  50.             {
  51.                 cin.clear();
  52.                 cin.ignore(512, '\n');
  53.                 cout << "Input error " << endl;
  54.                 cout << "Input number of processes" << endl;
  55.                 cin >> row;
  56.             }          
  57.     }  
  58.    
  59.     int array[row][cols] = {{0,0,0,0,0}};
  60.    
  61.     cout << endl;
  62.     cout << "------------------------------" << endl;
  63.     cout << "Arrival Time" << endl;
  64.    
  65.     for(int input = 0 ; input < row ; input++)
  66.     {
  67.        
  68.            
  69.             array[input][0] = input+1;
  70.             cout << "Input arrival time of process of " << " Process "  << array[input][0]  << endl;
  71.             cin >> array[input][1];
  72.            
  73.             while(!cin)
  74.             {
  75.                 cin.clear();
  76.                 cin.ignore(512, '\n');
  77.                 cout << "Input error" << endl;
  78.                 cout << "Input arrival time of process of " << " Process "  << array[input][0]  << endl;
  79.                 cin >> array[input][1];
  80.             }
  81.             cout << endl;
  82.     }
  83.    
  84.     cout << endl;
  85.     cout << "------------------------------" << endl;
  86.     cout << "Burst Time" << endl;
  87.    
  88.     for(int secondinput = 0 ; secondinput < row; secondinput++)
  89.     {
  90.                  
  91.             cout << "Input the burst time of " << "Process " << array[secondinput][0]<< endl;
  92.             cin >> array[secondinput][2];
  93.            
  94.             while(!cin)
  95.             {
  96.                 cin.clear();
  97.                 cin.ignore(512, '\n');
  98.                 cout << "Input error" << endl;
  99.                 cout << "Input the burst time  " << endl;
  100.                 cin >> array[secondinput][2];
  101.             }
  102.             cout << endl;
  103.            
  104.     }
  105.    
  106.     for(int sort = 0 ; sort < row - 1 ; sort ++)
  107.     {
  108.         for(int sort2 = 0; sort2 < row-sort-1 ; sort2++)
  109.         {
  110.             if(array[sort2][1] > array[sort2+1][1])            
  111.             {
  112.                 temp_var = array[sort2][0];                
  113.                 array[sort2][0] = array[sort2+1][0];            // Process Number Swap
  114.                 array[sort2+1][0] = temp_var;
  115.                
  116.                 temp_var = array[sort2][1];
  117.                 array[sort2][1] = array[sort2+1][1];            // Arrival Time Swap
  118.                 array[sort2+1][1] =  temp_var;
  119.                
  120.                 temp_var = array[sort2][2];
  121.                  array[sort2][2] =  array[sort2+1][2];          // Burst Time Swap
  122.                  array[sort2+1][2] = temp_var;
  123.                  
  124.                  temp_var = array[sort2][3];
  125.                 array[sort2][3] = array[sort2+1][3];            // Wait time Swap
  126.                 array[sort2+1][3]= temp_var;
  127.                
  128.                
  129.                 temp_var = array[sort2][4];
  130.                 array[sort2][4] = array[sort2+1][4];            //Turn Around Time Swap
  131.                 array[sort2+1][4] = temp_var;
  132.                  
  133.             }
  134.         }
  135.     }
  136.     cout << "Sorted" << endl;
  137.     cout << "------------------------------" << endl;
  138.     cout << "Process\t" << "Arrival Time\t"  << "Burst Time" << endl;
  139.     for(int print = 0; print < row ; print++)
  140.     {
  141.         cout << array[print][0] << "\t" << array[print][1] << "\t\t\t" << array[print][2] << endl;
  142.     }
  143.    
  144.     for(int c = 0; c < row; c++)
  145.     {
  146.         if(c == 0)
  147.         {
  148.            
  149.            
  150.            
  151.             start_time = array[c][1];
  152.                
  153.             array[c][6] = start_time;      // index 6 for start time
  154.            
  155.            
  156.             end_time = start_time + array[c][2];
  157.             array[c][5] = end_time;   // index 5 for end time
  158.             if(array[c][1] - end_time > 0 )
  159.             {
  160.                 array[c][7] = array[c][1] - end_time;       // index 7 for idle time
  161.             }
  162.            
  163.             array[c][4] = end_time - array[c][1];  // index 4 for Turn Around Time
  164.             array[c][3] = array[c][4] - array[c][2]; // index  3 for Waiting Time
  165.            
  166.             average_at+= array[c][1];
  167.         average_bt+= array[c][2];
  168.         average_wt+= array[c][3];
  169.         average_tt+= array[c][4];
  170.             continue;
  171.         }
  172.         start_time = end_time;
  173.         if(array[c][1] - end_time > 0 )    
  174.         {
  175.             array[c][7] = array[c][1] - end_time;    
  176.             start_time = end_time + array[c][7];
  177.         }
  178.        
  179.            
  180.         array[c][6] = start_time;
  181.         end_time = start_time + array[c][2];
  182.         array[c][5] = end_time;
  183.         final_time = end_time;
  184.          array[c][4] = end_time - array[c][1];
  185.             array[c][3] = array[c][4] - array[c][2];
  186.         average_at+= array[c][1];
  187.         average_bt+= array[c][2];
  188.         average_wt+= array[c][3];
  189.         average_tt+= array[c][4];
  190.    
  191.        
  192.     }
  193.     average_at/=row;
  194.         average_bt/= row;
  195.         average_wt/= row;
  196.         average_tt/= row;
  197.     cout << endl << endl << endl;
  198.    
  199.     cout << "With Calculated Waiting Time and Turn Around Time" << endl;
  200.     cout << "+---------------------------------------------------------------------------+" << endl;
  201.     cout << "PID\t" << "Arrival Time\t" << "Burst Time\t" << "Waiting Time\t" << "Turn Around Time\t"  << endl;
  202.     for(int print = 0 ; print < row ; print++)
  203.     {
  204.         cout << array[print][0] << "\t     " << array[print][1] << "\t\t " << array[print][2] << "\t\t\t" << array[print][3] << "\t\t"<< array[print][4] << endl;
  205.     }
  206.     cout << "+---------------------------------------------------------------------------+" << endl;
  207.     cout << "Total Number of Process/es: " << row << endl;
  208.     cout << "Average Arrival Time: " << average_at << endl;
  209.     cout << "Average Waiting Time: " << average_wt << endl;
  210.     cout << "Average Burst Time: " << average_bt << endl;
  211.     cout << "Average Turnaround Time: " << average_tt << endl;
  212.     cout << "Process Endtime: " << final_time << endl;
  213.    
  214.    
  215.        
  216.     cout << "-----------------------------------------------------------------------------" << endl;
  217.     cout<< "\t\t\t\tGantt Chart" << endl;
  218.     cout << "      ";
  219.     // print Gantt chart (6 spaces)
  220.      for(int a = 0 ; a < 68; a++)
  221.     {
  222.         cout << "-";
  223.     }
  224.    
  225.     cout << endl;
  226.  
  227.    
  228.     cout << "      ";
  229.     for(int b = 0; b < 204; b++)
  230.     {
  231.         switch (b)
  232.         {
  233.             case 0:
  234.             case 7:
  235.             case 14:
  236.             case 21: // first line of barlines
  237.             case 28:
  238.                
  239.             case 34:
  240.            
  241.             case 41:
  242.             case 48:
  243.             case 55:
  244.             case 62:
  245.                  // 89 90 91 92 93 94 95 96 // 96 97 98 99 100 101 102 103
  246.                 //79 //  86 //  93 //
  247.    
  248.            
  249.             case 125:
  250.            
  251.             case 133:
  252.             case 140:
  253.             case 147:
  254.             case 154:
  255.            
  256.             case 160:
  257.             case 167:
  258.             case 174:
  259.             case 181:
  260.             case 188:  
  261.             case 193:
  262.            
  263.            
  264.             case 67:
  265.                
  266.            
  267.                 //135 middle barline right
  268.                 cout << "|";
  269.                 if(b == 67 || b == 125)
  270.                 {
  271.                     cout << endl;
  272.                 }
  273.                 break;
  274.                        
  275.             case 68:
  276.             case 126:
  277.                 //68 middle barline left
  278.                 if(b == 126)
  279.                 {
  280.                     cout << "      |";
  281.                     break;
  282.                 }
  283.                 cout << "      |";
  284.                
  285.                 break;
  286.            
  287.             case 71: //1
  288.             case 77:// 2
  289.             case 83://3
  290.             case 89: //4
  291.             case 94: //5
  292.             case 100: //6
  293.             case 106: // 7
  294.             case 112:
  295.             case 118:
  296.             case 123:
  297.                
  298.                
  299.                 if(counter < row)
  300.                 {
  301.                     cout << "P"  << array[counter][0];
  302.                     counter++;
  303.                 }
  304.                 else{
  305.                     cout << "x ";
  306.                 }
  307.                 break;
  308.        
  309.             default:
  310.                 cout << " ";
  311.                 break;
  312.         }
  313.     }
  314.  
  315.     cout << "  ";
  316.     for(int a = 0 ; a < 68; a++)
  317.     {
  318.         cout << "-";
  319.     }
  320.    
  321.     cout << endl;
  322.     cout << "      ";
  323.     for(int label = 0 ; label < 68; label++)
  324.     {
  325.         switch(label)
  326.         {
  327.             case 0:
  328.             case 7:
  329.             case 14:
  330.             case 21:
  331.             case 28:
  332.             case 35:
  333.             case 42:
  334.             case 49:
  335.             case 56:
  336.             case 63:
  337.             case 70:
  338.                 if(arraycounter <= row)
  339.                 {
  340.                     if(arraycounter == row)
  341.                     {
  342.                         cout << final_time;
  343.                         arraycounter++;
  344.                         break;
  345.                     }
  346.                     if(array[arraycounter][7] > 0)
  347.                     {
  348.                         cout <<"\b\b\b\b" <<array[arraycounter-1][5] << "|I| ";
  349.                    
  350.                     }
  351.                     cout << array[arraycounter][6];
  352.                    
  353.                    
  354.                     arraycounter++;
  355.                 }
  356.                 else{
  357.                     cout << "-";
  358.                 }
  359.                 break;
  360.                
  361.             default:
  362.                 cout << " ";
  363.                 break;
  364.         }
  365.     }
  366.     cout << endl;
  367.     cout << endl;
  368.    
  369.     while(idle < row-1)
  370.     {  
  371.         if(idle == 0)
  372.         {
  373.             cout << "Idle time before Process " << array[idle][0]  << " starts " << array[idle_counter][7] << endl;
  374.             idle_counter++;
  375.         }
  376.    
  377.         cout << "Idle time between Process " << array[idle][0] << " and " << array[idle+1][0] << " is: " << array[idle_counter][7] << endl;
  378.         idle++;
  379.         idle_counter++;
  380.     }
  381.  
  382. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement