1. #include "Planista.h"
2. PCB running;
3. Planista::Planista()
4. {
5.         for (int i = 0; i < 8; i++)
6.         {
7.                 kolejka_bool.push_back(false);
8.         }
9. }
10.  
11. Planista::~Planista()
12. {
13. }
14.  
15. void Planista::dodaj_do_kolejki(PCB &x) {
16.         if (x.Dynamic_priority == NULL)
17.         {
18.                 x.Dynamic_priority = x.Priority;
19.         }
20.         int nr = x.Dynamic_priority / 4;
21.         mapa_kolejek[nr].push_back(x);
22.         kolejka_bool.at(nr) = true;
23. }
24.  
25. void Planista::dzielnik_cpu() {
26.  
27.         for (int i = 0; i < 8; i++)                                                                                             //pętla sprawdzająca mape kolejek
28.         {
29.                 for (std::list<PCB>::iterator it = mapa_kolejek[i].begin(); it != mapa_kolejek[i].end(); it++)
30.                 {
31.                         if (it->PID == 1)
32.                         {
33.  
34.                         }
35.                         else
36.                         {
37.                                 it->CPU = it->CPU / 2;
38.                         }
39.                        
40.  
41.                 }
42.         }
43.  
44. }
45. void Planista::powrot_do_kolejki(PCB &x) {
46.         x.Dynamic_priority = x.Priority + (x.CPU / 2);
47.         int nr = x.Priority / 4;
48.         mapa_kolejek[nr].push_back(x);
49.         kolejka_bool.at(nr) = true;
50. }
51.  
52.  
53. void Planista::run(Tree &t) {
54.         std::vector<int> r = t.Ready_processes();
55.  
56.  
57.         for (int j = 0; j < r.size(); j++)
58.         {
59.                 bool go = true;
60.                 for (size_t i = 0; i < r_in_q.size(); i++)
61.                 {
62.                         if (t.Get_process(r[j]).PID == r_in_q[i]) {
63.                                 go = false;
64.                         }
65.                 }
66.                 if (go == true) {
67.                         dodaj_do_kolejki(t.Get_process(r[j]));
68.                         r_in_q.push_back(r[j]);
69.                 }
70.         }
71.  
72.         int i = 0;
73.         while (kolejka_bool.at(i) == false)                             //sprawdzanie pierwszej dostępnej kolejki w mapie
74.         {                                                                                               //sprawdzanie pierwszej dostępnej kolejki w mapie
75.                 if (kolejka_bool.at(i) == true)                         //sprawdzanie pierwszej dostępnej kolejki w mapie
76.                 {
77.                                                                                                         //sprawdzanie pierwszej dostępnej kolejki w mapie
78.                         break;                                                                  //sprawdzanie pierwszej dostępnej kolejki w mapie
79.                 }                                                                                       //sprawdzanie pierwszej dostępnej kolejki w mapie
80.                 i++;
81.                 if (i == 8)
82.                 {
83.                         return;
84.                 }
85.  
86.         }                                                                               //sprawdzanie pierwszej dostępnej kolejki w mapie
87.  
88.         PCB x = mapa_kolejek[i].front();
89.         mapa_kolejek[i].pop_front();
90.         if (mapa_kolejek[i].empty())
91.         {
92.                 kolejka_bool[i] == false;
93.         }
94.         running = x;
95.         running.Change_process_state(Running);
96. }
97.  
98.  
99.  
100.  
101.  
102. void Planista::make_zombie(PCB &actual, Tree &t, MemoryManager &mm) {
103.        
104.         actual.Change_process_state(Zombie);
105.         actual.Change_process_state(Terminated);
106.         running = actual;
107.         int nr = running.Priority / 4;
108.         if (mapa_kolejek[nr].empty())
109.         {
110.                 kolejka_bool[nr] = false;
111.         }
112.         t.Exit_1(running.PID, mm);
113. }
114.  
115. void Planista::check(PCB &actual, Tree &t) {
116.         if (actual.State !=Terminated)
117.         {
118.                 actual.Change_process_state(Ready);
119.                 running = actual;
120.         }
121.         if (actual.State == Terminated)
122.         {
123.                 running.PID = NULL;
124.         }
125.  
126.  
127.         if (running.PID == NULL)
128.         {
129.                 std::cout << "Start Planistyn";
130.                 run(t);
131.                 actual = running;
132.                 return;
133.         }
134.         if (running.PID != NULL)
135.         {
136.                 std::cout << "odkladanie procesun";
137.                 powrot_do_kolejki(running);
138.                 dzielnik_cpu();
139.                 run(t);
140.                 actual = running;
141.                 return;
142.         }
143. //      else
144. //      {
145. //              //std::cout << "Proces w Procesorzen";
146. //              actual = running;
147. //              return;
148. //      }
149.  
150. }
151. //void Planista::act(PCB &act) {
152. //      act = running;
153. //}