Advertisement
BSIT_21

CPU_Sched(Mangahis, Redondo)

Jul 29th, 2019
167
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 18.71 KB | None | 0 0
  1. #include<iostream>
  2.  
  3. using namespace std;
  4.  
  5. int main()
  6. {
  7.     int cols = 9;
  8.     int row = 5;
  9.     int temp = 0;
  10.  
  11.  
  12.  
  13.  
  14.  
  15.     string header ="";
  16.  
  17.  
  18.     int counter = 0;
  19.     int arraycounter = 0;
  20.     int response=0;
  21.  
  22.     int final_time = 0;
  23.  
  24.     int idle = 0;
  25.     int idle_counter= 0 ;
  26.  
  27.     int average_wt = 0;
  28.     int average_bt = 0;
  29.     int average_tt = 0 ;
  30.     int average_at = 0;
  31.  
  32.  
  33.  
  34.     cout << "Choose your CPU Scheduling Policy(1- FCFS\t2- SJF\t\t3- Priority)" << endl;
  35.     cin >> response;
  36.     while(cin.fail()|| response < 1 || response > 3)
  37.     {
  38.         cin.clear();
  39.         cin.ignore(512,'\n');
  40.         cout << "Invalid Input. Please try again." << endl;
  41.          cout << "Choose your CPU Scheduling(1- FCFS\t2- SJF\t\t3- Priority )" << endl;
  42.          cin>> response;
  43.     }
  44.     switch(response)
  45.     {
  46.         case 1:
  47.             header = "First Come, First Serve Scheduling";
  48.             break;
  49.  
  50.         case 2:
  51.             header = "Shortest Job First Scheduling";
  52.             break;
  53.  
  54.         case 3:
  55.             header = "Priority Scheduling";
  56.             break;
  57.     }
  58.  
  59.  
  60.     cout  << header   <<endl;
  61.     cout << "--------------------------------------------------------------------------------" << endl;
  62.     cout << "Input number of processes" << endl;
  63.     cin >> row;
  64.  
  65.     while(cin.fail())
  66.             {
  67.                 cin.clear();
  68.                 cin.ignore(512, '\n');
  69.                 cout << "Input error " << endl;
  70.                 cout << "Input number of processes" << endl;
  71.                 cin >> row;
  72.             }
  73.  
  74.     while(row>10 || row <= 0)
  75.     {
  76.         cout << "Processes cannot be more than 10 or less than 1. Please input another value." << endl;
  77.         cin >> row;
  78.         while(cin.fail())
  79.             {
  80.                 cin.clear();
  81.                 cin.ignore(512, '\n');
  82.                 cout << "Input error " << endl;
  83.                 cout << "Input number of processes" << endl;
  84.                 cin >> row;
  85.             }
  86.     }
  87.     /*  Indexes~
  88.     *   0 - PID
  89.     *   1 - Arv Time
  90.     *   2 - Burst Time
  91.     *   3 - Waiting Time
  92.     *   4 - Turnaround Time
  93.     *   5 - End Time
  94.     *   6 - Start Time
  95.     *   7 - Idle Time
  96.     *   8 - Priority (conditional)
  97.     *
  98.     */
  99.  
  100.     int cpuTime[row][cols] = {{0,0,0,0,0,0,0,0,0}};
  101.  
  102.     cout << endl;
  103.     cout << "------------------------------" << endl;
  104.     cout << "Arrival Time" << endl;
  105.  
  106.     for(int input = 0 ; input < row ; input++)
  107.     {
  108.  
  109.  
  110.             cpuTime[input][0] = input+1;
  111.             cout << "Input arrival time of process of " << " Process "  << cpuTime[input][0]  << endl;
  112.             cin >> cpuTime[input][1];
  113.  
  114.             while(!cin)
  115.             {
  116.                 cin.clear();
  117.                 cin.ignore(512, '\n');
  118.                 cout << "Input error" << endl;
  119.                 cout << "Input arrival time of process of " << " Process "  << cpuTime[input][0]  << endl;
  120.                 cin >> cpuTime[input][1];
  121.             }
  122.             cout << endl;
  123.     }
  124.  
  125.     cout << endl;
  126.     cout << "------------------------------" << endl;
  127.     cout << "Burst Time" << endl;
  128.  
  129.     for(int secondinput = 0 ; secondinput < row; secondinput++)
  130.     {
  131.  
  132.             cout << "Input the burst time of " << "Process " << cpuTime[secondinput][0]<< endl;
  133.             cin >> cpuTime[secondinput][2];
  134.  
  135.             while(!cin)
  136.             {
  137.                 cin.clear();
  138.                 cin.ignore(512, '\n');
  139.                 cout << "Input error" << endl;
  140.                 cout << "Input the burst time  " << endl;
  141.                 cin >> cpuTime[secondinput][2];
  142.             }
  143.             cout << endl;
  144.  
  145.     }
  146.      cout << "------------------------------" << endl;
  147.     cout << "Priority" << endl;
  148.     if(response == 3)
  149.     {
  150.         for(int prio = 0 ; prio < row ; prio++)
  151.         {
  152.             cout << "Input Priority level of Process " << cpuTime[prio][0] <<endl;
  153.             cin >> cpuTime[prio][8];
  154.             cout << endl;
  155.         }
  156.     }
  157.  
  158.  
  159.  
  160.  
  161.     for(int sortvar = 0 ; sortvar < row - 1 ; sortvar++)
  162.     {
  163.         for(int sort2 = 0; sort2 < row-sortvar-1 ; sort2++)
  164.         {
  165.             if(cpuTime[sort2][1] > cpuTime[sort2+1][1])        // according to arrival time
  166.             {
  167.                 temp = cpuTime[sort2][0];
  168.                 cpuTime[sort2][0] = cpuTime[sort2+1][0];            // Process Number Swap
  169.                 cpuTime[sort2+1][0] = temp;
  170.  
  171.                 temp= cpuTime[sort2][1];
  172.                 cpuTime[sort2][1] = cpuTime[sort2+1][1];            // Arrival Time Swap
  173.                 cpuTime[sort2+1][1] =  temp;
  174.  
  175.                 temp = cpuTime[sort2][2];
  176.                  cpuTime[sort2][2] =  cpuTime[sort2+1][2];          // Burst Time Swap
  177.                  cpuTime[sort2+1][2] = temp;
  178.  
  179.                  temp = cpuTime[sort2][8];
  180.                  cpuTime[sort2][8]= cpuTime[sort2+1][8];
  181.                  cpuTime[sort2+1][8] = temp;
  182.  
  183.             }
  184.         }
  185.     }
  186.  
  187.  
  188.     cout << "Sorted(Acc. Arrival Time)" << endl;
  189.     cout << "------------------------------" << endl;
  190.     cout << "Process\t" << "Arrival Time\t"  << "Burst Time\t";
  191.     cout << endl;
  192.     for(int print = 0; print < row ; print++)
  193.     {
  194.         cout << cpuTime[print][0] << "\t" << cpuTime[print][1] << "\t\t\t" << cpuTime[print][2] << "\t";
  195.         cout << endl;
  196.     }
  197.  
  198.  
  199.  
  200.     if(response == 2)                               // if user chooses SJF hmmm~
  201.     {
  202.  
  203.         for(int sortvar = 0; sortvar < row - 1; sortvar++)  // starts with the first index cause the first process would already be the lowest arrival time (not needed to be sorted no moreee)~
  204.         {
  205.             for(int sort2 = 1; sort2< row-sortvar-1; sort2++)
  206.             {
  207.                 if(cpuTime[sort2][2]> cpuTime[sort2+1][2])
  208.                 {
  209.                      temp = cpuTime[sort2][0];
  210.                 cpuTime[sort2][0] = cpuTime[sort2+1][0];            // Process Number Swap
  211.                 cpuTime[sort2+1][0] = temp;
  212.  
  213.                 temp = cpuTime[sort2][1];
  214.                 cpuTime[sort2][1] = cpuTime[sort2+1][1];            // Arrival Time Swap
  215.                 cpuTime[sort2+1][1] =  temp;
  216.  
  217.                 temp = cpuTime[sort2][2];
  218.                  cpuTime[sort2][2] =  cpuTime[sort2+1][2];          // Burst Time Swap
  219.                  cpuTime[sort2+1][2] = temp;
  220.  
  221.  
  222.                 }
  223.             }
  224.         }
  225.  
  226.  
  227.  
  228.     cout << "Sorted(Acc. Burst Time)" << endl;
  229.     cout << "------------------------------" << endl;
  230.     cout << "Process\t" << "Arrival Time\t"  << "Burst Time\t" << endl;
  231.  
  232.         for(int print = 0 ; print < row; print++)
  233.         {
  234.             cout << cpuTime[print][0] << "\t" << cpuTime[print][1] << "\t\t\t" << cpuTime[print][2] << endl;
  235.         }
  236.     }
  237.  
  238.  
  239.  
  240.  
  241.  
  242.        if(response == 3) // Fixed proper Prio scheduling within a given end time
  243.     {
  244.         if(cpuTime[0][1] > 0)
  245.         {
  246.             cpuTime[0][7] = cpuTime[0][1];
  247.         }
  248.         cpuTime[0][6] = cpuTime[0][1];
  249.         cpuTime[0][5] = cpuTime[0][1] + cpuTime[0][2];
  250.  
  251.         for(int cal = 1 ; cal < row ; cal++)
  252.         {
  253.             if(cpuTime[cal-1][5] >= cpuTime[cal][1])
  254.             {
  255.                 for(int mov = cal+1; mov < row ; mov++)
  256.                 {
  257.                     if(cpuTime[cal][8] > cpuTime[mov][8] && cpuTime[mov][1] < cpuTime[cal-1][5])
  258.                     {
  259.                         temp = cpuTime[cal][0];
  260.                         cpuTime[cal][0] = cpuTime[mov][0];
  261.                         cpuTime[mov][0] = temp;
  262.  
  263.                         temp = cpuTime[cal][1];
  264.                         cpuTime[cal][1] = cpuTime[mov][1];
  265.                         cpuTime[mov][1] = temp;
  266.  
  267.                         temp = cpuTime[cal][2];
  268.                         cpuTime[cal][2] = cpuTime[mov][2];
  269.                         cpuTime[mov][2] = temp;
  270.  
  271.                         temp = cpuTime[cal][8];
  272.                         cpuTime[cal][8] = cpuTime[mov][8];
  273.                         cpuTime[mov][8] = temp;
  274.                     }
  275.                 }
  276.                 cpuTime[cal][6] = cpuTime[cal-1][5];
  277.             }
  278.             else{
  279.                 cpuTime[cal][6] = cpuTime[cal][1];
  280.                 cpuTime[cal][7] = cpuTime[cal][1]- cpuTime[cal-1][5];
  281.             }
  282.  
  283.  
  284.                 cpuTime[cal][5] = cpuTime[cal][6] + cpuTime[cal][2];
  285.                 cpuTime[cal][3] = cpuTime[cal][6] - cpuTime[cal][1];
  286.                 cpuTime[cal][4] = cpuTime[cal][5] - cpuTime[cal][1];
  287.  
  288.  
  289.  
  290.  
  291.         }
  292.         cout << "Sorted (Acc. Priority Level)" << endl;
  293.         cout << "------------------------------" << endl;
  294.         cout << "Process\t" << "Arrival Time\t"  << "Burst Time\t" << endl;
  295.         for(int print =0 ; print < row; print++)
  296.         {
  297.             cout << cpuTime[print][0] << "\t\t" << cpuTime[print][1] << "\t\t\t" << cpuTime[print][2] << "\t\t" << cpuTime[print][8] << endl;
  298.         }
  299.     }
  300.  
  301.     /*  Indexes~
  302.     *   0 - PID
  303.     *   1 - Arv Time
  304.     *   2 - Burst Time
  305.     *   3 - Waiting Time
  306.     *   4 - Turnaround Time
  307.     *   5 - End Time
  308.     *   6 - Start Time
  309.     *   7 - Idle Time
  310.     *   8 - Priority (conditional)
  311.     *
  312.     */
  313.  
  314.     for(int cal = 0; cal < row; cal++)          //Getting the start time, end time, waiting time, turnaround time of each process
  315.     {
  316.         if(cal == 0)
  317.         {
  318.                 cpuTime[cal][6] = cpuTime[cal][1]; // start time would be the arrival time of first proc
  319.                 if(cpuTime[cal][1]>0)
  320.                 {
  321.                     cpuTime[cal][7] = cpuTime[cal][1];
  322.  
  323.                 }
  324.                 cpuTime[cal][5] = cpuTime[cal][1] + cpuTime[cal][2]; // et = at + bt
  325.                 cpuTime[cal][3] = cpuTime[cal][6] - cpuTime[cal][1]; // wt = st - at
  326.                 cpuTime[cal][4] = cpuTime[cal][5] - cpuTime[cal][1]; // tt = et - at
  327.                 average_at+= cpuTime[cal][1];
  328.                 average_bt+= cpuTime[cal][2];
  329.                 average_wt+= cpuTime[cal][3];
  330.                 average_tt+= cpuTime[cal][4];
  331.  
  332.                 continue;
  333.         }
  334.  
  335.         if(cpuTime[cal][1] - cpuTime[cal-1][5] > 0) // if curr arv time - previous end time > 0 then implement idle time
  336.         {
  337.  
  338.             cpuTime[cal][7] = cpuTime[cal][1] - cpuTime[cal-1][5];
  339.             cpuTime[cal][6] = cpuTime[cal][1];
  340.         }
  341.  
  342.         else{
  343.             cpuTime[cal][6] = cpuTime[cal-1][5];
  344.         }
  345.         cpuTime[cal][5] = cpuTime[cal][6] + cpuTime[cal][2]; // et = at + bt
  346.         cpuTime[cal][3] = cpuTime[cal][6] - cpuTime[cal][1]; // wt = st - at
  347.         cpuTime[cal][4] = cpuTime[cal][5] - cpuTime[cal][1];
  348.         average_at+= cpuTime[cal][1];
  349.         average_bt+= cpuTime[cal][2];
  350.         average_wt+= cpuTime[cal][3];
  351.         average_tt+= cpuTime[cal][4];
  352.         if(cal == row - 1)
  353.         {
  354.             final_time = cpuTime[cal][5];
  355.         }
  356.  
  357.     }
  358.  
  359.  
  360.  
  361.  
  362.  
  363.     average_at/=row;
  364.     average_bt/= row;
  365.     average_wt/= row;
  366.     average_tt/= row;
  367.     cout << endl << endl << endl;
  368.  
  369.     cout << "With Calculated Waiting Time and Turn Around Time" << endl;
  370.     cout << "+---------------------------------------------------------------------------+" << endl;
  371.     cout << "PID\t" << "Arrival Time\t" << "Burst Time\t" << "Waiting Time\t" << "Turn Around Time\t";
  372.     if(response == 3)
  373.     {
  374.         cout << "Priority";
  375.     }
  376.     cout << endl;
  377.     for(int print = 0 ; print < row ; print++)
  378.     {
  379.         cout << cpuTime[print][0] << "\t     " << cpuTime[print][1] << "\t\t " << cpuTime[print][2] << "\t\t\t" << cpuTime[print][3] << "\t\t"<< cpuTime[print][4] << "\t\t\t";
  380.         if(response == 3)
  381.         {
  382.             cout << cpuTime[print][8];
  383.         }
  384.         cout << endl;
  385.     }
  386.     cout << "+---------------------------------------------------------------------------+" << endl;
  387.     cout << "Type of Scheduling: " << header << endl;
  388.     cout << "Total Number of Process/es: " << row << endl;
  389.     cout << "Average Arrival Time: " << average_at << endl;
  390.     cout << "Average Waiting Time: " << average_wt << endl;
  391.     cout << "Average Burst Time: " << average_bt << endl;
  392.     cout << "Average Turnaround Time: " << average_tt << endl;
  393.     cout << "Process Endtime: " << final_time << endl;
  394.  
  395.     /*  Indexes~
  396.     *   0 - PID
  397.     *   1 - Arv Time
  398.     *   2 - Burst Time
  399.     *   3 - Waiting Time
  400.     *   4 - Turnaround Time
  401.     *   5 - End Time
  402.     *   6 - Start Time
  403.     *   7 - Idle Time
  404.     *   8 - Priority (conditional)
  405.     *
  406.     */
  407.  
  408.  
  409.  
  410.  
  411.  
  412.  
  413.     cout << "-----------------------------------------------------------------------------" << endl;
  414.     cout<< "\t\t\t\tGantt Chart" << endl;
  415.     cout << "      ";
  416.  
  417.  
  418.     // Gantt Chart Start
  419.      for(int a = 0 ; a < 68; a++)
  420.     {
  421.         cout << "-";
  422.     }
  423.  
  424.  
  425.     cout << endl;
  426.  
  427.  
  428.     cout << "      ";
  429.     for(int b = 0; b < 204; b++)
  430.     {
  431.         switch (b)
  432.         {
  433.             case 0:
  434.  
  435.             case 2: // idle block first line
  436.             case 5:
  437.             case 9:
  438.             case 12:
  439.             case 16:
  440.             case 19:
  441.             case 23:
  442.             case 26:
  443.             case 30:
  444.             case 32:
  445.             case 36:
  446.             case 39:
  447.             case 43:
  448.             case 46:
  449.             case 50:
  450.             case 53:
  451.             case 57:
  452.             case 60:
  453.             case 64: // last idle block first line
  454.  
  455.             case 70: // first idle block second line
  456.             case 72:
  457.             case 76:
  458.             case 78:
  459.             case 82:
  460.             case 84:
  461.             case 88:
  462.             case 90:
  463.             case 93:
  464.             case 95:
  465.             case 99:
  466.             case 101:
  467.             case 104:
  468.             case 107:
  469.             case 110:
  470.             case 113:
  471.             case 116:
  472.             case 119:
  473.             case 122:
  474.  
  475.             case 128:
  476.             case 131: /// 3rd idle
  477.             case 135:
  478.             case 138:
  479.             case 142:
  480.             case 145:
  481.             case 149:
  482.             case 152:
  483.             case 156:
  484.             case 158:
  485.             case 162:
  486.             case 165:
  487.             case 169:
  488.             case 172:
  489.             case 176:
  490.             case 179:
  491.             case 183:
  492.             case 186:
  493.             case 190:
  494.  
  495.  
  496.  
  497.  
  498.             case 7:
  499.             case 14:
  500.             case 21: // first line of barlines
  501.             case 28:
  502.  
  503.             case 34:
  504.  
  505.             case 41:
  506.             case 48:
  507.             case 55:
  508.             case 62:
  509.  
  510.  
  511.             case 125:
  512.  
  513.  
  514.             case 133:
  515.             case 140:
  516.             case 147:
  517.             case 154:
  518.  
  519.             case 160:
  520.             case 167:
  521.             case 174:
  522.             case 181:
  523.             case 188:
  524.             case 193:
  525.  
  526.  
  527.  
  528.             case 67:
  529.  
  530.  
  531.                 //135 middle barline right
  532.                 cout << "|";
  533.                 if(b == 67 || b == 125)
  534.                 {
  535.                     cout << endl;
  536.                 }
  537.                 break;
  538.  
  539.  
  540.  
  541.             case 68:
  542.             case 126:
  543.                 //68 middle barline left
  544.                 if(b == 126)
  545.                 {
  546.                     cout << "      |";
  547.                     break;
  548.                 }
  549.                 cout << "      |";
  550.  
  551.                 break;
  552.  
  553.             case 71: //1
  554.             case 77:// 2
  555.             case 83://3
  556.             case 89: //4
  557.             case 94: //5
  558.             case 100: //6
  559.             case 106: // 7
  560.             case 112:
  561.             case 118:
  562.             case 123:
  563.  
  564.  
  565.                 if(counter < row)
  566.                 {
  567.                     cout << "P"  << cpuTime[counter][0];
  568.                     counter++;
  569.                 }
  570.                 else{
  571.                     cout << " x";
  572.                 }
  573.                 break;
  574.  
  575.             case 69:
  576.             case 74:
  577.             case 80:
  578.             case 86:
  579.             case 92:
  580.             case 98:
  581.             case 103:
  582.             case 109:
  583.             case 114:
  584.             case 120:
  585.                 if(idle_counter < row)
  586.                 {
  587.  
  588.  
  589.                 if(cpuTime[idle_counter][7] > 0)
  590.                 {
  591.                     cout << "I";
  592.                     idle_counter++;
  593.                 }
  594.  
  595.                 else{
  596.                     cout << " ";
  597.                     idle_counter++;
  598.                 }
  599.                 }
  600.  
  601.                 break;
  602.  
  603.             default:
  604.                 cout << " ";
  605.                 break;
  606.         }
  607.     }
  608.     cout << endl;
  609.     cout << "      ";
  610.  
  611.     for(int a = 0 ; a < 68; a++)
  612.     {
  613.         cout << "-";
  614.     }
  615.     idle_counter= 0; // reset counter~~
  616.  
  617.     cout << endl;
  618.     cout << "      ";
  619.     for(int label = 0 ; label < 68; label++)
  620.     {
  621.         switch(label)
  622.         {
  623.             case 0:
  624.             case 7:
  625.             case 14:
  626.             case 21:
  627.             case 28:
  628.             case 35:
  629.             case 42:
  630.             case 49:
  631.             case 56:
  632.             case 63:
  633.             case 70:
  634.                 if(arraycounter <= row)
  635.                 {
  636.                     if(arraycounter == row)
  637.                     {
  638.                         cout << final_time;
  639.                         arraycounter++;
  640.                         break;
  641.                     }
  642.  
  643.                     if(cpuTime[arraycounter][7] > 0) // if next index of idle time > 0
  644.                     {
  645.                         if(arraycounter == 0)
  646.                         {
  647.                             cout << "|I|";
  648.  
  649.                         }
  650.                         else{
  651.                             cout <<"\b\b\b\b" <<cpuTime[arraycounter-1][5] << "|I|";
  652.                         }
  653.  
  654.  
  655.                     }
  656.                     cout << cpuTime[arraycounter][6];
  657.  
  658.  
  659.                     arraycounter++;
  660.                 }
  661.                 else{
  662.                     cout << "-";
  663.                 }
  664.                 break;
  665.  
  666.             default:
  667.                 cout << " ";
  668.                 break;
  669.         }
  670.     }
  671.     cout << endl;
  672.     cout << endl;
  673.  
  674.     while(idle < row-1)
  675.     {
  676.         if(idle == 0)
  677.         {
  678.             cout << "Idle time before Process " << cpuTime[idle][0]  << " starts " << cpuTime[idle_counter][7] << endl;
  679.             idle_counter++;
  680.         }
  681.  
  682.         cout << "Idle time between Process " << cpuTime[idle][0] << " and " << cpuTime[idle+1][0] << " is: " << cpuTime[idle_counter][7] << endl;
  683.         idle++;
  684.         idle_counter++;
  685.         }
  686.  
  687.      for(int sortvar = 0 ; sortvar < row - 1 ; sortvar++)
  688.     {
  689.         for(int sort2 = 0; sort2 < row-sortvar-1 ; sort2++)
  690.         {
  691.             if(cpuTime[sort2][0] > cpuTime[sort2+1][0])        // according to arrival time
  692.             {
  693.                 temp = cpuTime[sort2][0];
  694.                 cpuTime[sort2][0] = cpuTime[sort2+1][0];            // Process Number Swap
  695.                 cpuTime[sort2+1][0] = temp;
  696.  
  697.                 temp= cpuTime[sort2][1];
  698.                 cpuTime[sort2][1] = cpuTime[sort2+1][1];            // Arrival Time Swap
  699.                 cpuTime[sort2+1][1] =  temp;
  700.  
  701.                 temp = cpuTime[sort2][2];
  702.                  cpuTime[sort2][2] =  cpuTime[sort2+1][2];          // Burst Time Swap
  703.                  cpuTime[sort2+1][2] = temp;
  704.  
  705.                  temp = cpuTime[sort2][3];
  706.                  cpuTime[sort2][3]= cpuTime[sort2+1][3];
  707.                  cpuTime[sort2+1][3] = temp;
  708.  
  709.                  temp = cpuTime[sort2][4];
  710.                  cpuTime[sort2][4]= cpuTime[sort2+1][4];
  711.                  cpuTime[sort2+1][4] = temp;
  712.  
  713.             }
  714.         }
  715.     }
  716.     cout << endl;
  717.     cout << "+---------------------------------------------------------------------------+" << endl;
  718.     cout << "Process ID Sorted With Calculated Waiting Time and Turn Around Time" << endl;
  719.     cout << "+---------------------------------------------------------------------------+" << endl;
  720.     cout << "PID\t" << "Arrival Time\t" << "Burst Time\t" << "Waiting Time\t" << "Turn Around Time\t";
  721.     if(response == 3)
  722.     {
  723.         cout << "Priority";
  724.     }
  725.     cout << endl;
  726.     for(int print = 0 ; print < row ; print++)
  727.     {
  728.         cout << cpuTime[print][0] << "\t     " << cpuTime[print][1] << "\t\t " << cpuTime[print][2] << "\t\t\t" << cpuTime[print][3] << "\t\t"<< cpuTime[print][4] << "\t\t\t";
  729.         if(response == 3)
  730.         {
  731.             cout << cpuTime[print][8];
  732.         }
  733.         cout << endl;
  734.     }
  735.     cout << "+---------------------------------------------------------------------------+" << endl;
  736. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement