1. #include <iostream>
2. #include <vector>
3. #include <string>
4.  
5.  
6. struct Process
7. {
8.         int PID;
9.         int processState; //0=virgin, 1=running, 2=waiting, 3=ready, 4=terminated;
10.         std::string name;
11.  
12.         Process* parent; //procesy przedstawiają drzewo, gdzie rodzic jest procesem macierzystym
13.         std::vector<Process*> children; //a dzieci jego procesami potomnymi
14.  
15.         int regA;    // 4 wartości rejestrów procesora
16.         int regB;
17.         int regC;
18.         int regD;
19.  
20.         int programCounter; //wskazuje następną instrukcję do wykonania
21.         std::string programData; //kod programu
22.         //std::string programText; //kod programu
23.         Process* programPosition;
24.         bool processBlocked;
25.        
26.         Process(int ID, Process* father, std::string processName) //konstruktor procesu;
27.         {
28.                 processState = 0;
29.                 processBlocked = false;
30.                 PID = ID;
31.                 parent = father;
32.                 name = processName;
33.         }
34. };
35.  
36. struct Karuzela
37. {
38.         std::vector<Process*> karuzela;
39.         void AddProcess(Process* process)
40.         {
41.                 karuzela.push_back(process);
42.         }
43. };
44. //struct RAM //przykładowa tablica pamięci RAM
45. //{
46. //      int Ram[128];
47. //      void WriteToMemory(Process* process);
48. //};
49.  
50.  
51. struct ProcessManagment
52. {
53.         Process* init = new Process(0, nullptr, "name"); //proces, który wytwarza się przy startowaniu systemu
54.         //RAM* Ram = new RAM; //tablica pamięci od zarządzania pamiecią
55.         Karuzela* Karuzela;
56.  
57.         ProcessManagment()
58.         {
59.                 init->PID = 0; //uzupełnianie procesu inicjijącego
60.                 init->name = "name";
61.                 init->parent = nullptr;
62.         }
63.  
64.         Process* FindProcess(int ID, Process* init) //funkcja przeszukująca drzewo procesów
65.         {
66.                 if (init->PID == ID) //jeżeli ID procesu się zgadza z szukanym
67.                 {
68.                         return init; //koniec rekurencji, zwraca znaleziony proces w postaci wskaźnika
69.                 }
70.                 else
71.                 {      
72.                         int i = 0;
73.                         while(init->children[i]) //jeżeli dzieci istnieją
74.                         {  
75.                                 i++;
76.                                 return FindProcess(ID, init->children[i]); //wykonaj rekurencje
77.                         }
78.                         return nullptr;
79.                 }
80.         }
81.  
82.         int FindID() //znajdywanie wolnego ID
83.         {
84.                 int ID=0;
85.                 while (FindProcess(ID, init)) //sprawdzanie czy ID jest juz używane
86.                 {
87.                         ID++;
88.                 }
89.                 return ID;
90.         }
91.  
92.         void AddProcess(std::string processName, int parentID = 0)
93.         {
94.                 Process* virgin = new Process(FindID(), FindProcess(parentID, init), processName); //tworzenie procesu
95.                 virgin->processState = 3; //status na ready
96.                 FindProcess(parentID, init)->children.push_back(virgin); //dodawanie do listy potomków dla rodzimego procesu
97.                 Karuzela->AddProcess(virgin); //dodawanie do kolejki dla zarządzania procesami
98.                 //Ram->WriteToMemory(virgin); //wywoływanie pamięci, orzepisuje program
99.         }
100.         int Fork(Process* parent) //dodaj proces potomny
101.         {
102.                 Process* child = new Process(FindID(), parent, parent->name);
103.                
104.                 child->regA = parent->regA; //potomek, jest kopią procesu macierzystego, ale ma inny ID
105.                 child->regB = parent->regB;
106.                 child->regC = parent->regC;
107.                 child->regD = parent->regD;
108.  
109.                 child->programCounter = parent->programCounter;
110.  
111.                 parent->children.push_back(child);
112.                 Karuzela->AddProcess(child);
113.                 //Ram->WriteToMemory(child);
114.         }
115.         void KillProcess(int ID)
116.         {
117.                 delete FindProcess(ID, init); //usuwanie wskaźnika do procesu w drzewie
118.         }
119.         void ChangeState(int ID, int newstate)
120.         {
121.                 FindProcess(ID, init)->processState = newstate; //szukanie w drzewie procesu i zmiana jego stanu
122.         }
123.         void PrintProcess(int ID)
124.         {
125.                 std::cout << "Process " <<FindProcess(ID, init)->PID << ": with parent ID " << FindProcess(ID, init)->parent << std::endl;
126.         }
127.         void PrintAllProcesses(int ID)
128.         {
129.                 if (init->PID == ID) //jeżeli ID procesu się zgadza z szukanym
130.                 {
131.                         std::cout << "Process " << FindProcess(ID, init)->PID << ": with parent ID " << FindProcess(ID, init)->parent << std::endl;
132.                 }
133.                 else
134.                 {
135.                         int i = 0;
136.                         while (init->children[i]) //jeżeli dzieci istnieją
137.                         {
138.                                 std::cout << "Process " << FindProcess(init->children[i]->PID, init)->PID << ": with parent ID " << FindProcess(ID, init)->parent << std::endl;
139.                                 i++;
140.                         }
141.                 }
142.                
143.         }
144. };
145.  
146. int main()
147. {
148.         ProcessManagment list;
149.         list.AddProcess("amelia", 0);
150.         return 0;
151. }