SHARE
TWEET

Untitled

a guest Apr 19th, 2019 98 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <iostream>
  2. #include<fstream>
  3. #include<cstdlib>
  4. #include<vector>
  5. #include<deque>
  6. #include<queue>
  7. #include<algorithm>
  8. using namespace std;
  9.  
  10.  
  11. struct process
  12. {
  13.  
  14.     int id ;
  15.     int cputime;
  16.     int IOtime;
  17.     int arrivaltime;
  18.     int status; // 0 for ready and any other number for blocked
  19.     int startarrivetime;
  20.     int totaltime;
  21. };
  22. int cpu_clock=0;
  23.  
  24.  
  25. bool sortbooling(process a,process b);
  26. void debugger(deque<process> p,int num);
  27. void Runningprocess(deque<process> p);
  28. void Blockedprocess(deque<process> p);
  29. void Readyprocess(deque<process> p);
  30.  
  31.  
  32.  
  33. int main()
  34. {
  35.     process temp_process;
  36.     //vector<process>list_of_processes();
  37.     deque<process>list_of_processes;
  38.     deque<process>blockedqueue;
  39.     deque<process>readyqueue;
  40.  
  41.     int numberofprocesses=0;
  42.  
  43.     int numberofblocked=0;
  44.     int uselesscputime=0;
  45.     int numberofready=0;
  46.  
  47.     char filename[50]= {"os.txt"};
  48.     ifstream file;
  49.     //cin.getline(filename,50);
  50.     file.open(filename);
  51.  
  52.     if (!file.is_open())exit(EXIT_FAILURE);
  53.     char word[50];
  54.     // file>>word;
  55.     while(file.good())
  56.     {
  57.         file>>word;
  58.         temp_process.id=atoi(word);
  59.         file>>word;
  60.         temp_process.cputime=atoi(word);
  61.         file>>word;
  62.         temp_process.IOtime=atoi(word);
  63.         file>>word;
  64.         temp_process.arrivaltime=atoi(word);
  65.         temp_process.status=0;
  66.         temp_process.startarrivetime=temp_process.arrivaltime;
  67.         temp_process.totaltime=temp_process.arrivaltime;
  68.  
  69.         list_of_processes.push_back(temp_process);
  70.  
  71.         cout <<temp_process.id <<" ";
  72.         cout <<temp_process.cputime <<" ";
  73.         cout <<temp_process.IOtime <<" ";
  74.         cout <<temp_process.arrivaltime <<"a"<<endl;
  75.  
  76.  
  77.         numberofprocesses++;
  78.     }
  79.     //cout << list_of_processes.at(1).arrivaltime<<endl;
  80.  
  81.     sort(list_of_processes.begin(),list_of_processes.end(),sortbooling);
  82.     //cout << list_of_processes.size();
  83.     //cout << list_of_processes.at(1).arrivaltime<<endl;
  84.  
  85.     cout<<"Processes"<<endl;
  86.     debugger(list_of_processes, numberofprocesses);
  87. //FCFS
  88.  
  89.     for(;;)
  90.     {
  91.  
  92.  
  93.         if (list_of_processes.empty()&&blockedqueue.empty())
  94.         {
  95.             //if()
  96.             break;
  97.  
  98.         }
  99.  
  100.         cout<<cpu_clock<<":";
  101.         if(list_of_processes.at(0).arrivaltime<=cpu_clock )
  102.         {
  103.             int j=1;
  104.             while(3)
  105.             {
  106.                 if(numberofprocesses==1)break;
  107.                 if(list_of_processes.at(j).arrivaltime<=cpu_clock)readyqueue.push_back(list_of_processes.at(j));
  108.                 else break;
  109.                 j++;
  110.                 numberofready++;
  111.  
  112.             }
  113.  
  114.             if (list_of_processes.at(0).status==0)
  115.             {
  116.  
  117.  
  118.  
  119. //list_of_processes.at(0).totaltime=list_of_processes.at(0).cputime+cpu_clock
  120.                 for (int i=list_of_processes.at(0).cputime; i!=0; i--)
  121.                 {
  122.                     Runningprocess(list_of_processes);
  123.                     //blocked check
  124.                     if(!readyqueue.empty())
  125.                     {
  126.                         for (int i=0; i<numberofready; i++)
  127.                         {
  128.                             Readyprocess(blockedqueue);
  129.  
  130.  
  131.  
  132.                         }
  133.                     }
  134.  
  135.  
  136.                     if(!blockedqueue.empty())
  137.                     {
  138.                         for (int i=0; i<numberofblocked; i++)
  139.                         {
  140.                             Blockedprocess(blockedqueue);
  141.                             blockedqueue.at(i).status--;
  142.                             if (blockedqueue.at(i).status==0)
  143.                             {
  144.                                 blockedqueue.at(i).arrivaltime=cpu_clock;
  145.                                 blockedqueue.at(i).IOtime=0;
  146.                                 list_of_processes.push_back(blockedqueue.at(i));
  147.                                 blockedqueue.erase(blockedqueue.begin()+i);
  148.                                 numberofblocked--;
  149.                                 numberofprocesses++;
  150.  
  151.                             }
  152.                         }
  153.                     }
  154.                     //
  155.                     cpu_clock++;
  156.                 }
  157.  
  158.                 if (list_of_processes.at(0).IOtime==0)
  159.                 {
  160.                     numberofprocesses--;
  161.                     list_of_processes.at(0).totaltime=cpu_clock;
  162.                     list_of_processes.pop_front();
  163.  
  164.  
  165.                 }
  166.                 else
  167.                 {
  168.                     list_of_processes.at(0).status=list_of_processes.at(0).IOtime;
  169.                     list_of_processes.at(0).cputime=1;
  170.                     blockedqueue.push_back(list_of_processes.at(0));
  171.                     list_of_processes.pop_front();
  172.                     numberofblocked++;
  173.                     numberofprocesses--;
  174.  
  175.  
  176.  
  177.  
  178.                 }
  179.  
  180.  
  181.  
  182.  
  183.  
  184.                 //ready to start
  185.  
  186.             }
  187.         }
  188.         else if(!blockedqueue.empty())
  189.         {
  190.  
  191.             //it's a blocked process
  192.             for (int i=0; i<numberofblocked; i++)
  193.             {
  194.                 Blockedprocess(blockedqueue);
  195.                 blockedqueue.at(i).status--;
  196.                 if (blockedqueue.at(i).status==0)
  197.                 {
  198.                     blockedqueue.at(i).arrivaltime=cpu_clock;
  199.                     blockedqueue.at(i).IOtime=0;
  200.                     list_of_processes.push_back(blockedqueue.at(i));
  201.                     blockedqueue.erase(blockedqueue.begin()+i);
  202.                     numberofblocked--;
  203.                     numberofprocesses++;
  204.  
  205.                 }
  206.             }
  207.  
  208.  
  209.  
  210.             cpu_clock++;
  211.             uselesscputime++;
  212.         }
  213.  
  214.  
  215.  
  216.  
  217.  
  218.  
  219.  
  220.  
  221.  
  222.  
  223.  
  224.  
  225.         else
  226.         {
  227.  
  228.  
  229.             //the processor is free and no processes to work
  230.             uselesscputime++;
  231.             cpu_clock++;
  232.         }
  233.         cout<<endl;
  234.         sort(list_of_processes.begin(),list_of_processes.end(),sortbooling);
  235.         //cout<<"Processes"<<endl;
  236.         //debugger(list_of_processes, numberofprocesses);
  237.         //cout<<"blocked"<<endl;
  238.         //debugger(blockedqueue, numberofblocked);
  239.         readyqueue.clear();
  240.         numberofready=0;
  241.  
  242.  
  243.  
  244.     }
  245.  
  246.  
  247.  
  248.  
  249.     return 0;
  250. }
  251.  
  252.  
  253.  
  254. bool sortbooling(process a,process b)
  255. {
  256.  
  257.     return ((a.arrivaltime<b.arrivaltime)||((a.arrivaltime==b.arrivaltime)&&(a.id<b.id)));
  258.  
  259. }
  260.  
  261. void debugger(deque<process> p,int num)
  262. {
  263.     for (int i=0; i<num; i++)
  264.     {
  265.  
  266.         cout<<p.at(i).id<<endl;
  267.  
  268.     }
  269.  
  270. }
  271.  
  272.  
  273. void Runningprocess(deque<process> p)
  274. {
  275.  
  276.     cout<<"        i am running process";
  277.  
  278.  
  279.  
  280. }
  281. void Readyprocess(deque<process> p)
  282. {
  283.  
  284.     cout<<"       i am Ready process";
  285.  
  286.  
  287.  
  288. }
  289.  
  290.  
  291. void Blockedprocess(deque<process> p)
  292. {
  293.  
  294.  
  295.     cout<<"         i am blocked process";
  296.  
  297.  
  298.  
  299.  
  300.  
  301.  
  302. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top