1. #include "Planista.h"
2.  
3. PCB running;
4.  
5. Planista::Planista()
6. {
7.         for (int i = 0; i < 8; i++)
8.         {
9.                 kolejka_bool.push_back(false);
10.         }
11.         gotowe = 0;
12. }
13.  
14. Planista::~Planista()
15. {
16. }
17.  
18. void Planista::dodaj_do_kolejki(PCB &x) {
19.         if (x.Dynamic_priority == NULL)
20.         {
21.                 x.Dynamic_priority = x.Priority;
22.         }
23.         int nr = x.Dynamic_priority / 4;
24.         mapa_kolejek[nr].push_back(x);
25.         kolejka_bool.at(nr) = true;
26. }
27.  
28. void Planista::dzielnik_cpu() {
29.  
30.         for (int i = 0; i < 8; i++)                                                                                             //pętla sprawdzająca mape kolejek
31.         {
32.                 for (std::list<PCB>::iterator it = mapa_kolejek[i].begin(); it != mapa_kolejek[i].end(); it++)
33.                 {
34.                         if (it->PID == 1)
35.                         {
36.  
37.                         }
38.                         else
39.                         {
40.                                 it->CPU = it->CPU / 2; std::cout << "Podzielono! \n";
41.                         }
42.                        
43.  
44.                 }
45.         }
46.  
47. }
48. void Planista::powrot_do_kolejki(PCB &x) {
49.         x.Dynamic_priority = x.Priority + (x.CPU / 2);
50.         int nr = x.Priority / 4;
51.         mapa_kolejek[nr].push_back(x);
52.         kolejka_bool.at(nr) = true;
53. }
54.  
55.  
56. void Planista::run(Tree &t) {
57.         std::vector<PCB> r = t.Ready_processes();
58.  
59.        
60.         for (; gotowe < r.size(); gotowe++)
61.         {
62.                 dodaj_do_kolejki(r[gotowe]);
63.         }
64.         int i = 0;
65.         while (kolejka_bool.at(i) == false)                             //sprawdzanie pierwszej dostępnej kolejki w mapie
66.         {                                                                                               //sprawdzanie pierwszej dostępnej kolejki w mapie
67.                 if (kolejka_bool.at(i) == true)                         //sprawdzanie pierwszej dostępnej kolejki w mapie
68.                 {                                                                                       //sprawdzanie pierwszej dostępnej kolejki w mapie
69.                         break;                                                                  //sprawdzanie pierwszej dostępnej kolejki w mapie
70.                 }                                                                                       //sprawdzanie pierwszej dostępnej kolejki w mapie
71.                 i++;
72.                 if (i == 8)
73.                 {
74.                         return;
75.                 }
76.  
77.         }                                                                               //sprawdzanie pierwszej dostępnej kolejki w mapie
78.  
79.         PCB x = mapa_kolejek[i].front();
80.         mapa_kolejek[i].pop_front();
81.         running = x;
82.         running.Change_process_state(Running);
83. }
84.  
85.  
86.  
87.  
88.  
89. void Planista::make_zombie() {
90.        
91.  
92.         running.Change_process_state(Zombie);
93.         running.Change_process_state(Terminated);
94.         running.PID = NULL;
95. }
96.  
97. void Planista::check(PCB &actual, Tree &t) {
98.         actual.Change_process_state(Ready);
99.         if (running.PID == NULL)
100.         {
101.                 std::cout << "Start Planisty\n";
102.                 run(t);
103.                 actual = running;
104.                 return;
105.         }
106.         if (running.PID != NULL)
107.         {
108.                 running = actual;
109.                 std::cout << "odkładanie procesu\n";
110.                 powrot_do_kolejki(running);
111.                 dzielnik_cpu();
112.                 run(t);
113.        
114.                 return;
115.         }
116.         else
117.         {
118.                 //std::cout << "Proces w Procesorze\n";
119.                 actual = running;
120.                 return;
121.         }
122.  
123. }
124.