API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jan 21st, 2020
74
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 19.59 KB | None | 0 0
raw download clone embed print report
  1. #include <iostream>
  2. #include <fstream>
  3. using namespace std;
  4. #define MAX 100
  5.  
  6. double sredni_czas_oczekiwania, sredni_czas_cyklu_przetwarzania;
  7. int suma_czasu_oczekiwania, suma_czasu_cyklu_przetwarzania, porownanie, liczba_procesow = 0;
  8.  
  9. struct Proces
  10. {
  11. int pid = -1;
  12. int czas_przybycia;
  13. int czas_fazy_procesora;
  14. int czas_fazy_procesora_sjf_w;
  15. int czas_oczekiwania = 0;
  16. int czas_cyklu_przetwarzania = 0;
  17. int czas_wykonania = 0;
  18. };
  19.  
  20. Proces p[MAX];
  21.  
  22. void drukuj_tabele_sjf_w()
  23. {
  24. cout << "+-----+---------------+----------------+---------------------+----------------+------------------+--------------------------+" << endl;
  25. cout << "| PID | Nazwa procesu | Czas przybycia | Czas fazy procesora | Czas wykonania | Czas oczekiwania | Czas cyklu przetwarzania |" << endl;
  26. cout << "+-----+---------------+----------------+---------------------+----------------+------------------+--------------------------+" << endl;
  27.  
  28. for (int i = 0; i<liczba_procesow; i++) {
  29. printf("| %2d | P%d | %2d | %2d | %2d | %2d | %2d |\n"
  30. , p[i].pid, p[i].pid, p[i].czas_przybycia, p[i].czas_fazy_procesora_sjf_w, p[i].czas_wykonania, p[i].czas_oczekiwania, p[i].czas_cyklu_przetwarzania);
  31. cout << "+-----+---------------+----------------+---------------------+----------------+------------------+--------------------------+" << endl;
  32. }
  33.  
  34. }
  35.  
  36. void drukuj_tabele_fcfs_sjf()
  37. {
  38. cout << "+-----+---------------+----------------+---------------------+----------------+------------------+--------------------------+" << endl;
  39. cout << "| PID | Nazwa procesu | Czas przybycia | Czas fazy procesora | Czas wykonania | Czas oczekiwania | Czas cyklu przetwarzania |" << endl;
  40. cout << "+-----+---------------+----------------+---------------------+----------------+------------------+--------------------------+" << endl;
  41.  
  42. for (int i = 0; i<liczba_procesow; i++) {
  43. printf("| %2d | P%d | %2d | %2d | %2d | %2d | %2d |\n"
  44. , p[i].pid, p[i].pid, p[i].czas_przybycia, p[i].czas_fazy_procesora, p[i].czas_wykonania, p[i].czas_oczekiwania, p[i].czas_cyklu_przetwarzania);
  45. cout << "+-----+---------------+----------------+---------------------+----------------+------------------+--------------------------+" << endl;
  46. }
  47.  
  48. }
  49.  
  50. void drukuj_tabele()
  51. {
  52. cout << "+-----+---------------+----------------+---------------------+" << endl;
  53. cout << "| PID | Nazwa procesu | Czas przybycia | Czas fazy procesora |" << endl;
  54. cout << "+-----+---------------+----------------+---------------------+" << endl;
  55.  
  56. for (int i = 0; i<liczba_procesow; i++) {
  57. printf("| %2d | P%d | %2d | %2d |\n"
  58. , p[i].pid, p[i].pid, p[i].czas_przybycia, p[i].czas_fazy_procesora);
  59. cout << "+-----+---------------+----------------+---------------------+" << endl;
  60. }
  61.  
  62. }
  63.  
  64. void obliczenie_czasu_oczekiwania_i_przetwarzania(Proces p[], int rozmiar, int numer)
  65. {
  66. int btt = p[0].czas_fazy_procesora;
  67. suma_czasu_oczekiwania = 0;
  68. suma_czasu_cyklu_przetwarzania = 0;
  69. switch (numer)
  70. {
  71. case 2:
  72. p[0].czas_oczekiwania = 0;
  73. p[0].czas_cyklu_przetwarzania = p[0].czas_fazy_procesora;
  74. p[0].czas_wykonania = p[0].czas_fazy_procesora;
  75. for (int i = 1; i<rozmiar; i++) {
  76. p[i].czas_oczekiwania = btt - p[i].czas_przybycia;
  77. btt = btt + p[i].czas_fazy_procesora;
  78. p[i].czas_cyklu_przetwarzania = p[i].czas_oczekiwania + p[i].czas_fazy_procesora;
  79. p[i].czas_wykonania = p[i].czas_cyklu_przetwarzania + p[i].czas_przybycia;
  80. }
  81. for (int i = 0; i<rozmiar; i++) {
  82. suma_czasu_oczekiwania = suma_czasu_oczekiwania + p[i].czas_oczekiwania;
  83. suma_czasu_cyklu_przetwarzania = suma_czasu_cyklu_przetwarzania + p[i].czas_cyklu_przetwarzania;
  84. }
  85. sredni_czas_oczekiwania = (double)suma_czasu_oczekiwania / (double)rozmiar;
  86. sredni_czas_cyklu_przetwarzania = (double)suma_czasu_cyklu_przetwarzania / (double)rozmiar;
  87. break;
  88. case 3:
  89. for (int i = 1; i<rozmiar; i++) {
  90. p[i].czas_cyklu_przetwarzania = p[i].czas_wykonania - p[i].czas_przybycia;
  91. p[i].czas_oczekiwania = p[i].czas_cyklu_przetwarzania - p[i].czas_fazy_procesora;
  92. }
  93. for (int i = 0; i<rozmiar; i++) {
  94. suma_czasu_oczekiwania = suma_czasu_oczekiwania + p[i].czas_oczekiwania;
  95. suma_czasu_cyklu_przetwarzania = suma_czasu_cyklu_przetwarzania + p[i].czas_cyklu_przetwarzania;
  96. }
  97. sredni_czas_oczekiwania = (double)suma_czasu_oczekiwania / (double)rozmiar;
  98. sredni_czas_cyklu_przetwarzania = (double)suma_czasu_cyklu_przetwarzania / (double)rozmiar;
  99. break;
  100. case 4:
  101. for (int i = 0; i < rozmiar; i++)
  102. {
  103. p[i].czas_cyklu_przetwarzania = p[i].czas_wykonania - p[i].czas_przybycia;
  104. p[i].czas_oczekiwania = p[i].czas_cyklu_przetwarzania - p[i].czas_fazy_procesora_sjf_w;
  105. }
  106. for (int i = 0; i<rozmiar; i++) {
  107. suma_czasu_oczekiwania = suma_czasu_oczekiwania + p[i].czas_oczekiwania;
  108. suma_czasu_cyklu_przetwarzania = suma_czasu_cyklu_przetwarzania + p[i].czas_cyklu_przetwarzania;
  109. }
  110. sredni_czas_oczekiwania = (double)suma_czasu_oczekiwania / (double)rozmiar;
  111. sredni_czas_cyklu_przetwarzania = (double)suma_czasu_cyklu_przetwarzania / (double)rozmiar;
  112. break;
  113. }
  114.  
  115. }
  116.  
  117. void liczenie_sjf_w(Proces p[], int rozmiar)
  118. {
  119. int i, j;
  120. for (i = 0; i < rozmiar - 1; i++)
  121. {
  122. for (j = i + 1; j < rozmiar; j++)
  123. {
  124. if (p[i].pid > p[j].pid)
  125. {
  126. swap(p[i], p[j]);
  127. }
  128. }
  129. }
  130. for (i = rozmiar; i > 0; i--)
  131. {
  132. cout << p[i - 1].pid << " : " << p[i - 1].czas_cyklu_przetwarzania << "-" << p[i - 1].czas_fazy_procesora_sjf_w << " = " << p[i - 1].czas_oczekiwania << " ms\n";
  133. }
  134. cout << "Sredni czas oczekiwania = (";
  135. for (i = rozmiar; i > 0; i--)
  136. {
  137. cout << p[i - 1].czas_oczekiwania << "+";
  138. }
  139. cout << ")/" << rozmiar << " = " << sredni_czas_oczekiwania << " ms\n\n";
  140. for (i = rozmiar; i > 0; i--)
  141. {
  142. cout << p[i - 1].pid << " : " << p[i - 1].czas_wykonania << "-" << p[i - 1].czas_przybycia << " = " << p[i - 1].czas_cyklu_przetwarzania << " ms\n";
  143. }
  144. cout << "Sredni czas cyklu przetwarzania = (";
  145. for (i = rozmiar; i > 0; i--)
  146. {
  147. cout << p[i - 1].czas_cyklu_przetwarzania << "+";
  148. }
  149. cout << ")/" << rozmiar << " = " << sredni_czas_cyklu_przetwarzania << " ms\n\n";
  150. }
  151.  
  152. void liczenie_sjf(Proces p[], int rozmiar)
  153. {
  154. int i, j;
  155. for (i = 0; i<rozmiar - 1; i++)
  156. {
  157. for (j = i + 1; j<rozmiar; j++)
  158. {
  159. if (p[i].pid > p[j].pid)
  160. {
  161. swap(p[i], p[j]);
  162. }
  163. }
  164. }
  165. for (i = rozmiar; i>0; i--)
  166. {
  167. cout << p[i - 1].pid << " : " << p[i - 1].czas_cyklu_przetwarzania << "-" << p[i - 1].czas_fazy_procesora << " = " << p[i - 1].czas_oczekiwania << " ms\n";
  168. }
  169. cout << "Sredni czas oczekiwania = (";
  170. for (i = rozmiar; i>0; i--)
  171. {
  172. cout << p[i - 1].czas_oczekiwania << "+";
  173. }
  174. cout << ")/" << rozmiar << " = " << sredni_czas_oczekiwania << " ms\n\n";
  175. for (i = rozmiar; i>0; i--)
  176. {
  177. cout << p[i - 1].pid << " : " << p[i - 1].czas_wykonania << "-" << p[i - 1].czas_przybycia << " = " << p[i - 1].czas_cyklu_przetwarzania << " ms\n";
  178. }
  179. cout << "Sredni czas cyklu przetwarzania = (";
  180. for (i = rozmiar; i>0; i--)
  181. {
  182. cout << p[i - 1].czas_cyklu_przetwarzania << "+";
  183. }
  184. cout << ")/" << rozmiar << " = " << sredni_czas_cyklu_przetwarzania << " ms\n\n";
  185. }
  186.  
  187. void liczenie_fcfs(Proces p[], int rozmiar)
  188. {
  189. int i, j;
  190. for (i = 0; i<rozmiar - 1; i++)
  191. {
  192. for (j = i + 1; j<rozmiar; j++)
  193. {
  194. if (p[i].pid > p[j].pid)
  195. {
  196. swap(p[i], p[j]);
  197. }
  198. }
  199. }
  200. for (i = rozmiar; i>0; i--)
  201. {
  202. cout << p[i - 1].pid << " : " << p[i - 1].czas_cyklu_przetwarzania << "-" << p[i - 1].czas_fazy_procesora << " = " << p[i - 1].czas_oczekiwania << " ms\n";
  203. }
  204. cout << "Sredni czas oczekiwania = (";
  205. for (i = rozmiar; i>0; i--)
  206. {
  207. cout << p[i - 1].czas_oczekiwania<< "+";
  208. }
  209. cout << ")/" << rozmiar << " = " << sredni_czas_oczekiwania << " ms\n\n";
  210. for (i = rozmiar; i>0; i--)
  211. {
  212. cout << p[i - 1].pid << " : " << p[i - 1].czas_wykonania << "-" << p[i - 1].czas_przybycia << " = " << p[i - 1].czas_cyklu_przetwarzania << " ms\n";
  213. }
  214. cout << "Sredni czas cyklu przetwarzania = (";
  215. for (i = rozmiar; i>0; i--)
  216. {
  217. cout << p[i - 1].czas_cyklu_przetwarzania << "+";
  218. }
  219. cout << ")/" << rozmiar << " = " << sredni_czas_cyklu_przetwarzania << " ms\n\n";
  220. }
  221.  
  222. void gantt(Proces p[], int rozmiar)
  223. {
  224. int i, j;
  225.  
  226. cout << " ";
  227. for (i = 0; i<rozmiar; i++) {
  228. for (j = 0; j<p[i].czas_fazy_procesora; j++) cout << "--";
  229. cout << " ";
  230. }
  231. cout << "\n|";
  232.  
  233. for (i = 0; i<rozmiar; i++) {
  234. for (j = 0; j<p[i].czas_fazy_procesora - 1; j++) cout << " ";
  235. cout << "P" << p[i].pid;
  236. for (j = 0; j<p[i].czas_fazy_procesora - 1; j++) cout << " ";
  237. cout << "|";
  238. }
  239. cout << "\n ";
  240.  
  241. for (i = 0; i<rozmiar; i++) {
  242. for (j = 0; j<p[i].czas_fazy_procesora; j++) cout << "--";
  243. cout << " ";
  244. }
  245. cout << "\n";
  246.  
  247. cout << "0";
  248. for (i = 0; i<rozmiar; i++) {
  249. for (j = 0; j<p[i].czas_fazy_procesora; j++) cout << " ";
  250. if (p[i].czas_wykonania > 9) cout << "\b";
  251. cout << p[i].czas_wykonania;
  252.  
  253. }
  254. cout << "\n";
  255. }
  256.  
  257. void sort_fcfs(Proces p[], int rozmiar)
  258. {
  259. for (int i = 0; i < rozmiar; i++)
  260. {
  261. for (int j = 0; j < rozmiar - 1; j++)
  262. {
  263. if (p[j].czas_przybycia > p[j + 1].czas_przybycia)
  264. swap(p[j], p[j + 1]);
  265. }
  266. }
  267. }
  268.  
  269. void sort_sjf_n(Proces p[], int rozmiar)
  270. {
  271. int j = 0, i = 0;
  272.  
  273. for (int i = 0; i < rozmiar; i++)
  274. {
  275. for (int j = 0; j < rozmiar - 1; j++)
  276. {
  277. if (p[j].czas_przybycia > p[j + 1].czas_przybycia || p[j].czas_przybycia == p[j + 1].czas_przybycia && p[j].czas_fazy_procesora > p[j + 1].czas_fazy_procesora)
  278. swap(p[j], p[j + 1]);
  279. }
  280. }
  281.  
  282. p[0].czas_wykonania = p[0].czas_fazy_procesora + p[0].czas_przybycia;
  283. p[0].czas_cyklu_przetwarzania = p[0].czas_wykonania - p[0].czas_przybycia;
  284. p[0].czas_oczekiwania = p[0].czas_cyklu_przetwarzania - p[0].czas_fazy_procesora;
  285.  
  286. for (i = 1; i<rozmiar; i++)
  287. {
  288. porownanie = p[i - 1].czas_wykonania;
  289. for (int j = i; j < rozmiar - 1; j++)
  290. {
  291. if (p[j].czas_fazy_procesora > p[j+1].czas_fazy_procesora && p[j].czas_przybycia <= porownanie)
  292. swap(p[j], p[j + 1]);
  293. }
  294. if (p[i - 1].czas_wykonania<p[i].czas_przybycia)
  295. {
  296. p[i].czas_wykonania = p[i - 1].czas_wykonania + p[i].czas_fazy_procesora + (p[i].czas_przybycia - p[i - 1].czas_wykonania);
  297. }
  298. else
  299. {
  300. p[i].czas_wykonania = p[i - 1].czas_wykonania + p[i].czas_fazy_procesora;
  301. }
  302. }
  303. }
  304.  
  305. void sort_sjf_w(Proces p[], int rozmiar)
  306. {
  307.  
  308. int i, j, pcom;
  309.  
  310. for (i = 0; i < rozmiar; i++)
  311. {
  312. p[i].czas_fazy_procesora_sjf_w = p[i].czas_fazy_procesora;
  313. }
  314.  
  315. for (int i = 0; i < rozmiar; i++)
  316. {
  317. for (int j = 0; j < rozmiar - 1; j++)
  318. {
  319. if (p[j].czas_przybycia > p[j + 1].czas_przybycia)
  320. swap(p[j], p[j + 1]);
  321. }
  322. }
  323.  
  324. i = 0;
  325. pcom = 0;
  326. while (pcom<rozmiar)
  327. {
  328. for (j = 0; j<rozmiar; j++)
  329. {
  330. if (p[j].czas_przybycia>i)
  331. break;
  332. }
  333.  
  334. for (int i = 0; i < j; i++)
  335. {
  336. for (int k = 0; k < j - 1; k++)
  337. {
  338. if (p[k].czas_fazy_procesora > p[k + 1].czas_fazy_procesora)
  339. swap(p[k], p[k + 1]);
  340. }
  341. }
  342.  
  343. if (j>0)
  344. {
  345. for (j = 0; j<rozmiar; j++)
  346. {
  347. if (p[j].czas_fazy_procesora != 0)
  348. break;
  349. }
  350. if (p[j].czas_przybycia>i)
  351. {
  352. i = p[j].czas_przybycia;
  353. }
  354. p[j].czas_wykonania = i + 1;
  355. p[j].czas_fazy_procesora--;
  356. }
  357. i++;
  358. pcom = 0;
  359. for (j = 0; j<rozmiar; j++)
  360. {
  361. if (p[j].czas_fazy_procesora == 0)
  362. pcom++;
  363. }
  364. }
  365. }
  366.  
  367. bool wczytajPlik(string nazwaPliku)
  368. {
  369. int i = 0;
  370. liczba_procesow = 0;
  371. ifstream plik;
  372. plik.open( nazwaPliku.c_str() );
  373. if (!plik.good())
  374. return false;
  375. while ( !plik.eof() )
  376. {
  377. plik >> p[i].pid >> p[i].czas_przybycia >> p[i].czas_fazy_procesora;
  378. i++;
  379. liczba_procesow++;
  380. }
  381. return true;
  382. }
  383.  
  384. void zapiszPlik(string nazwaPliku, Proces p[], int rozmiar, int numer)
  385. {
  386. ofstream plik;
  387. plik.open(nazwaPliku.c_str());
  388. plik << "Przed wykonaniem:\n";
  389. plik << "+-----+---------------+----------------+---------------------+" << endl;
  390. plik << "| PID | Nazwa procesu | Czas przybycia | Czas fazy procesora |" << endl;
  391. plik << "+-----+---------------+----------------+---------------------+" << endl;
  392. switch (numer)
  393. {
  394. case 2:
  395. sort_fcfs(p, rozmiar);
  396. break;
  397. case 3:
  398. sort_sjf_n(p, rozmiar);
  399. break;
  400. }
  401. switch (numer)
  402. {
  403. case 2:
  404. case 3:
  405. for (int i = 0; i<rozmiar; i++)
  406. {
  407. plik << "| " << p[i].pid << " | P" << p[i].pid << " | " << p[i].czas_przybycia << " | " << p[i].czas_fazy_procesora << " |\n";
  408. plik << "+-----+---------------+----------------+---------------------+" << endl;
  409. }
  410. break;
  411. case 4:
  412. for (int i = 0; i<rozmiar; i++)
  413. {
  414. plik << "| " << p[i].pid << " | P" << p[i].pid << " | " << p[i].czas_przybycia << " | " << p[i].czas_fazy_procesora_sjf_w << " |\n";
  415. plik << "+-----+---------------+----------------+---------------------+" << endl;
  416. }
  417. break;
  418. }
  419. switch (numer)
  420. {
  421. case 2:
  422. case 3:
  423. plik << "Po wykonaniu posortowane w kolejności wykonania:\n";
  424. plik << "+-----+---------------+----------------+---------------------+------------------+------------------+--------------------------+" << endl;
  425. plik << "| PID | Nazwa procesu | Czas przybycia | Czas fazy procesora | Czas wykonania | Czas oczekiwania | Czas cyklu przetwarzania |" << endl;
  426. plik << "+-----+---------------+----------------+---------------------+------------------+------------------+--------------------------+" << endl;
  427.  
  428. for (int i = 0; i<rozmiar; i++)
  429. {
  430. plik << "| " << p[i].pid << " | P" << p[i].pid << " | " << p[i].czas_przybycia << " | " << p[i].czas_fazy_procesora << " | " << p[i].czas_wykonania << " | " << p[i].czas_oczekiwania << " | " << p[i].czas_cyklu_przetwarzania << " |\n";
  431. plik << "+-----+---------------+----------------+---------------------+------------------+------------------+--------------------------+" << endl;
  432. }
  433. break;
  434. case 4:
  435. plik << "Po wykonaniu posortowane w kolejności wykonania:\n";
  436. plik << "+-----+---------------+----------------+---------------------+------------------+------------------+--------------------------+" << endl;
  437. plik << "| PID | Nazwa procesu | Czas przybycia | Czas fazy procesora | Czas wykonania | Czas oczekiwania | Czas cyklu przetwarzania |" << endl;
  438. plik << "+-----+---------------+----------------+---------------------+------------------+------------------+--------------------------+" << endl;
  439.  
  440. for (int i = 0; i<rozmiar; i++)
  441. {
  442. plik << "| " << p[i].pid << " | P" << p[i].pid << " | " << p[i].czas_przybycia << " | " << p[i].czas_fazy_procesora_sjf_w << " | " << p[i].czas_wykonania << " | " << p[i].czas_oczekiwania << " | " << p[i].czas_cyklu_przetwarzania << " |\n";
  443. plik << "+-----+---------------+----------------+---------------------+------------------+------------------+--------------------------+" << endl;
  444. }
  445. break;
  446. }
  447. switch (numer)
  448. {
  449. case 2:
  450. plik << "\nObliczenia:\n";
  451. for (int i = rozmiar; i>0; i--)
  452. {
  453. plik << p[i - 1].pid << " = " << p[i - 1].czas_oczekiwania << "-" << p[i - 1].czas_przybycia << " = " << p[i - 1].czas_oczekiwania - p[i - 1].czas_przybycia << " ms\n";
  454. }
  455. plik << "Sredni czas oczekiwania = (";
  456. for (int i = rozmiar; i>0; i--)
  457. {
  458. plik << p[i - 1].czas_oczekiwania - p[i - 1].czas_przybycia << "+";
  459. }
  460. plik << ")/" << rozmiar << " = " << sredni_czas_oczekiwania << " ms\n\n";
  461. for (int i = rozmiar; i>0; i--)
  462. {
  463. plik << p[i - 1].pid << " = " << p[i - 1].czas_cyklu_przetwarzania << "-" << p[i - 1].czas_przybycia << " = " << p[i - 1].czas_cyklu_przetwarzania - p[i - 1].czas_przybycia << " ms\n";
  464. }
  465. plik << "Sredni czas cyklu przetwarzania = (";
  466. for (int i = rozmiar; i>0; i--)
  467. {
  468. plik << p[i - 1].czas_cyklu_przetwarzania - p[i - 1].czas_przybycia << "+";
  469. }
  470. plik << ")/" << rozmiar << " = " << sredni_czas_cyklu_przetwarzania << " ms\n\n";
  471. break;
  472. case 3:
  473. for (int i = rozmiar; i > 0; i--)
  474. {
  475. plik << p[i - 1].pid << " : " << p[i - 1].czas_cyklu_przetwarzania << "-" << p[i - 1].czas_przybycia << " = " << p[i - 1].czas_oczekiwania << " ms\n";
  476. }
  477. plik << "Sredni czas oczekiwania = (";
  478. for (int i = rozmiar; i > 0; i--)
  479. {
  480. plik << p[i - 1].czas_oczekiwania << "+";
  481. }
  482. plik << ")/" << rozmiar << " = " << sredni_czas_oczekiwania << " ms\n\n";
  483. for (int i = rozmiar; i > 0; i--)
  484. {
  485. plik << p[i - 1].pid << " : " << p[i - 1].czas_wykonania << "-" << p[i - 1].czas_przybycia << " = " << p[i - 1].czas_cyklu_przetwarzania << " ms\n";
  486. }
  487. plik << "Sredni czas cyklu przetwarzania = (";
  488. for (int i = rozmiar; i > 0; i--)
  489. {
  490. plik << p[i - 1].czas_cyklu_przetwarzania << "+";
  491. }
  492. plik << ")/" << rozmiar << " = " << sredni_czas_cyklu_przetwarzania << " ms\n\n";
  493. break;
  494. case 4:
  495. for (int i = rozmiar; i > 0; i--)
  496. {
  497. plik << p[i - 1].pid << " : " << p[i - 1].czas_cyklu_przetwarzania << "-" << p[i - 1].czas_fazy_procesora_sjf_w << " = " << p[i - 1].czas_oczekiwania << " ms\n";
  498. }
  499. plik << "Sredni czas oczekiwania = (";
  500. for (int i = rozmiar; i > 0; i--)
  501. {
  502. plik << p[i - 1].czas_oczekiwania << "+";
  503. }
  504. plik << ")/" << rozmiar << " = " << sredni_czas_oczekiwania << " ms\n\n";
  505. for (int i = rozmiar; i > 0; i--)
  506. {
  507. plik << p[i - 1].pid << " : " << p[i - 1].czas_wykonania << "-" << p[i - 1].czas_przybycia << " = " << p[i - 1].czas_cyklu_przetwarzania << " ms\n";
  508. }
  509. plik << "Sredni czas cyklu przetwarzania = (";
  510. for (int i = rozmiar; i > 0; i--)
  511. {
  512. plik << p[i - 1].czas_cyklu_przetwarzania << "+";
  513. }
  514. plik << ")/" << rozmiar << " = " << sredni_czas_cyklu_przetwarzania << " ms\n\n";
  515. break;
  516. }
  517. plik.close();
  518. }
  519.  
  520. int main()
  521. {
  522. char koniec = '1';
  523. wczytajPlik("dane.txt");
  524. cout << "Program sumulacyjny algorytmow planowania czasu procesora!" << endl;;
  525. while (koniec != 'k')
  526. {
  527. int numer, i = 0;
  528. cout << "[1] Wyswietl dane pobrane z pliku dane.txt." << endl;
  529. cout << "[2] Wykonaj algorytm FCFS." << endl;
  530. cout << "[3] Wykonaj algorytm SJF NIEWYWLASZCZAJACY." << endl;
  531. cout << "[4] Wykonaj algorytm SJF WYWLASZCZAJACY." << endl;
  532. cout << "[5] Koniec programu." << endl;
  533. cout << "Prosze wybrac numer operacji: ";
  534. cin >> numer;
  535. switch (numer)
  536. {
  537. case 1:
  538. drukuj_tabele();
  539. break;
  540. case 2:
  541. cout << "Algorytm FCFS:" << endl;
  542. sort_fcfs(p, liczba_procesow);
  543. obliczenie_czasu_oczekiwania_i_przetwarzania(p, liczba_procesow, numer);
  544. drukuj_tabele_fcfs_sjf();
  545. gantt(p, liczba_procesow);
  546. liczenie_fcfs(p, liczba_procesow);
  547. zapiszPlik("FCFS.txt", p, liczba_procesow, numer);
  548. cout << "Wynik algorytmu zapisany do pliku FCFS.txt!\n" << endl;
  549. break;
  550. case 3:
  551. cout << "Algorytm SJF NIEWYWLASZCZAJACY" << endl;
  552. sort_sjf_n(p, liczba_procesow);
  553. obliczenie_czasu_oczekiwania_i_przetwarzania(p, liczba_procesow, numer);
  554. drukuj_tabele_fcfs_sjf();
  555. gantt(p, liczba_procesow);
  556. liczenie_sjf(p, liczba_procesow);
  557. zapiszPlik("SJF.txt", p, liczba_procesow, numer);
  558. cout << "Wynik algorytmu zapisany do pliku SJF.txt!\n" << endl;
  559. break;
  560. case 4:
  561. cout << "Algorytm SJF WYWLASZCZAJACY" << endl;
  562. sort_sjf_w(p, liczba_procesow);
  563. obliczenie_czasu_oczekiwania_i_przetwarzania(p, liczba_procesow, numer);
  564. drukuj_tabele_sjf_w();
  565. liczenie_sjf_w(p, liczba_procesow);
  566. zapiszPlik("SJF_W.txt", p, liczba_procesow, numer);
  567. wczytajPlik("dane.txt");
  568. cout << "Wynik algorytmu zapisany do pliku SJF_W.txt!\n" << endl;
  569. break;
  570. case 5:
  571. koniec = 'k';
  572. break;
  573. default:
  574. break;
  575. }
  576. }
  577. return 0;
  578. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!