Advertisement
Dark_Shard

FCFS_Lect

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