1. #include "Planista.h"
2. PCB *running;
3. extern PCB *troll;
4. Planista::Planista()
5. {
6.         for (int i = 0; i < 8; i++)
7.         {
8.                 kolejka_bool.push_back(false);
9.         }
10.         r_in_q.push_back(1);
11. }
12.  
13. Planista::~Planista()
14. {
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;
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.         if (x.Dynamic_priority > 31) { x.Dynamic_priority = 31; }
51.         int nr = x.Dynamic_priority / 4;
52.         mapa_kolejek[nr].push_back(&x);
53.         kolejka_bool.at(nr) = true;
54. }
55.  
56.  
57.  
58.  
59. void Planista::run(Tree &t) {
60.         std::vector<int> r = t.Ready_processes();
61.  
62.        
63.         for (int j = 0; j < r.size(); j++)
64.         {
65.                 bool go = true;
66.                 for (size_t i = 0; i < r_in_q.size(); i++)
67.                 {
68.                         if (t.Get_process(r[j]).PID == r_in_q[i]) {
69.                                 go = false;
70.                         }
71.                 }
72.                 if (go == true) {
73.                         //std::cout << &t.Get_process(r[j]).PID << std::endl;
74.                         dodaj_do_kolejki((t).Get_process(r[j]));
75.                         r_in_q.push_back(r[j]);
76.                 }
77.         }
78.         int i = 0;
79.         while (kolejka_bool.at(i) == false)                             //sprawdzanie pierwszej dostępnej kolejki w mapie
80.         {                                                                                               //sprawdzanie pierwszej dostępnej kolejki w mapie
81.                 if (kolejka_bool.at(i) == true)                         //sprawdzanie pierwszej dostępnej kolejki w mapie
82.                 {
83.                                                                                                         //sprawdzanie pierwszej dostępnej kolejki w mapie
84.                         break;                                                                  //sprawdzanie pierwszej dostępnej kolejki w mapie
85.                 }                                                                                       //sprawdzanie pierwszej dostępnej kolejki w mapie
86.                 i++;
87.                 if (i==7 && mapa_kolejek.at(i).size()>1 && mapa_kolejek.at(i).front()->PID == 1)
88.                 {
89.                         PCB *x = mapa_kolejek[i].front();
90.                         mapa_kolejek[i].pop_front();
91.                         mapa_kolejek.at(i).push_back(x);
92.                 }
93.                 if (i == 8)
94.                 {
95.                         return;
96.                 }
97.  
98.         }                                                                                               //sprawdzanie pierwszej dostępnej kolejki w mapie
99.         //std::cout << &mapa_kolejek[i].front()->PID << "!!!" << std::endl;
100.        
101.         PCB *x = mapa_kolejek[i].front();
102.         //std::cout << &x->PID << "!!!" << std::endl;
103.         //std::cout << &x->PID << " x " << std::endl;
104.         mapa_kolejek[i].pop_front();
105.         if (mapa_kolejek[i].empty())
106.         {
107.                 kolejka_bool[i] = false;
108.         }
109.         running = x;
110.         running->Change_process_state(Running);
111.         //std::cout << &running->PID <<" [running run] " <<std::endl;
112.         troll = running;
113.         //std::cout << &troll->PID << " [running run troll] " << std::endl;
114. }
115.  
116.  
117.  
118.  
119.  
120. void Planista::make_zombie(PCB &actual, Tree &t, MemoryManager &mm) {
121.        
122.         actual.Change_process_state(Zombie);
123.         actual.Change_process_state(Terminated);
124.         running = &actual;
125.  
126.         int nr = running->Priority / 4;
127.         if (mapa_kolejek[nr].empty())
128.         {
129.                 kolejka_bool[nr] = false;
130.         }
131.         t.Exit_1(running->PID, mm);
132. }
133.  
134. void Planista::check(/*PCB *actual,*/ Tree &t) {
135.  
136.         //std::cout << &running->PID << " [running check]" << std::endl;
137.         //std::cout << actual->PID << " [actual check] " << std::endl;
138.         if (troll->State !=Terminated)
139.         {
140.                 troll->Change_process_state(Ready);
141.                 running = troll;
142.         /*      running = actual;*/
143.         }
144.         //std::cout << &running->PID << " running2 " << std::endl;
145.         if (troll->State == Terminated)
146.         {
147.                 running->PID = NULL;
148.         }
149.  
150.  
151.         if (running->PID == NULL)
152.         {
153.                 std::cout << "Start Planisty\n";
154.                 run(t);
155.                 *troll = *running;
156.                 return;
157.         }
158.         if (running->PID != NULL)
159.         {
160.                 std::cout << "odkladanie procesu\n";
161.                 powrot_do_kolejki(*running);
162.                 dzielnik_cpu();
163.                 run(t);
164.                 *troll = *running;
165.                 return;
166.         }
167. //      else
168. //      {
169. //              //std::cout << "Proces w Procesorze\n";
170. //              actual = running;
171. //              return;
172. //      }
173.  
174. }
175. //void Planista::act(PCB &act) {
176. //      act = running;
177. //}