ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂಗಳ ಪರಿಚಯ
ಹೇ ಹಬ್ರ್! ನನ್ನ ಅಭಿಪ್ರಾಯದಲ್ಲಿ ಒಂದು ಆಸಕ್ತಿದಾಯಕ ಸಾಹಿತ್ಯದ ಲೇಖನಗಳು-ಅನುವಾದಗಳ ಸರಣಿಯನ್ನು ನಿಮ್ಮ ಗಮನಕ್ಕೆ ತರಲು ನಾನು ಬಯಸುತ್ತೇನೆ - OSTEP. ಈ ವಸ್ತುವು ಯುನಿಕ್ಸ್ ತರಹದ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂಗಳ ಕೆಲಸವನ್ನು ಸಾಕಷ್ಟು ಆಳವಾಗಿ ಚರ್ಚಿಸುತ್ತದೆ, ಅವುಗಳೆಂದರೆ, ಪ್ರಕ್ರಿಯೆಗಳು, ವಿವಿಧ ಶೆಡ್ಯೂಲರ್‌ಗಳು, ಮೆಮೊರಿ ಮತ್ತು ಆಧುನಿಕ OS ಅನ್ನು ರೂಪಿಸುವ ಇತರ ರೀತಿಯ ಘಟಕಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ. ಎಲ್ಲಾ ವಸ್ತುಗಳ ಮೂಲವನ್ನು ನೀವು ಇಲ್ಲಿ ನೋಡಬಹುದು . ಅನುವಾದವನ್ನು ವೃತ್ತಿಪರವಲ್ಲದ (ಸಾಕಷ್ಟು ಮುಕ್ತವಾಗಿ) ಮಾಡಲಾಗಿದೆ ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ, ಆದರೆ ನಾನು ಸಾಮಾನ್ಯ ಅರ್ಥವನ್ನು ಉಳಿಸಿಕೊಂಡಿದ್ದೇನೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ.
ಈ ವಿಷಯದ ಕುರಿತು ಲ್ಯಾಬ್ ಕೆಲಸವನ್ನು ಇಲ್ಲಿ ಕಾಣಬಹುದು:
ಇತರ ಭಾಗಗಳು:
ನೀವು ನನ್ನ ಚಾನಲ್ ಅನ್ನು ಸಹ ಇಲ್ಲಿ ಪರಿಶೀಲಿಸಬಹುದು =)
ಯೋಜನೆ: ಬಹು-ಹಂತದ ಪ್ರತಿಕ್ರಿಯೆ ಸರತಿ
ಈ ಉಪನ್ಯಾಸದಲ್ಲಿ, ನಾವು ಅತ್ಯಂತ ಪ್ರಸಿದ್ಧವಾದ ವಿಧಾನಗಳಲ್ಲಿ ಒಂದನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವ ಸಮಸ್ಯೆಗಳ ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತೇವೆ
ಯೋಜನೆ, ಇದನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ ಬಹು-ಹಂತದ ಪ್ರತಿಕ್ರಿಯೆ ಸರತಿ (MLFQ). MLFQ ಶೆಡ್ಯೂಲರ್ ಅನ್ನು ಮೊದಲ ಬಾರಿಗೆ 1962 ರಲ್ಲಿ ಫರ್ನಾಂಡೋ ಜೆ. ಕಾರ್ಬಟೋ ಎಂಬ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ವಿವರಿಸಿದರು.
ಹೊಂದಾಣಿಕೆಯ ಸಮಯ ಹಂಚಿಕೆ ವ್ಯವಸ್ಥೆ (CTSS). ಈ ಕೃತಿಗಳು (ನಂತರದ ಕೆಲಸಗಳನ್ನು ಒಳಗೊಂಡಂತೆ
ಮಲ್ಟಿಟಿಕ್ಸ್) ತರುವಾಯ ಟ್ಯೂರಿಂಗ್ ಪ್ರಶಸ್ತಿಗೆ ನಾಮನಿರ್ದೇಶನಗೊಂಡಿತು. ಶೆಡ್ಯೂಲರ್ ಆಗಿತ್ತು
ತರುವಾಯ ಸುಧಾರಿಸಲಾಗಿದೆ ಮತ್ತು ಈಗಾಗಲೇ ಕಂಡುಬರುವ ನೋಟವನ್ನು ಪಡೆದುಕೊಂಡಿದೆ
ಕೆಲವು ಆಧುನಿಕ ವ್ಯವಸ್ಥೆಗಳು.
MLFQ ಅಲ್ಗಾರಿದಮ್ 2 ಮೂಲಭೂತ ಅತಿಕ್ರಮಿಸುವ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ.
ಮೊದಲನೆಯದಾಗಿ, ಇದು ಟರ್ನ್ಅರೌಂಡ್ ಸಮಯವನ್ನು ಆಪ್ಟಿಮೈಸ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ, ನಾವು ಹಿಂದಿನ ಉಪನ್ಯಾಸದಲ್ಲಿ ಚರ್ಚಿಸಿದಂತೆ, ಕ್ಯೂನ ತಲೆಯಿಂದ ಪ್ರಾರಂಭಿಸುವ ವಿಧಾನದಿಂದ ಆಪ್ಟಿಮೈಸ್ ಮಾಡಲಾಗಿದೆ
ಸಣ್ಣ ಕಾರ್ಯಗಳು. ಆದಾಗ್ಯೂ, ಈ ಅಥವಾ ಆ ಪ್ರಕ್ರಿಯೆಯು ಎಷ್ಟು ಸಮಯದವರೆಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು OS ಗೆ ತಿಳಿದಿಲ್ಲ, ಮತ್ತು ಇದು
SJF, STCF ಅಲ್ಗಾರಿದಮ್‌ಗಳ ಕಾರ್ಯಾಚರಣೆಗೆ ಅಗತ್ಯವಾದ ಜ್ಞಾನ. ಎರಡನೆಯದಾಗಿ, MLFQ ಪ್ರಯತ್ನಿಸುತ್ತದೆ
ಬಳಕೆದಾರರಿಗೆ ಸಿಸ್ಟಮ್ ಅನ್ನು ಸ್ಪಂದಿಸುವಂತೆ ಮಾಡಿ (ಉದಾಹರಣೆಗೆ, ಕುಳಿತುಕೊಳ್ಳುವವರಿಗೆ ಮತ್ತು
ಕಾರ್ಯವು ಪೂರ್ಣಗೊಳ್ಳಲು ಕಾಯುತ್ತಿರುವಾಗ ಪರದೆಯ ಮೇಲೆ ದಿಟ್ಟಿಸುವುದು) ಮತ್ತು ಹೀಗೆ ಸಮಯವನ್ನು ಕಡಿಮೆ ಮಾಡಿ
ಪ್ರತಿಕ್ರಿಯೆ ದುರದೃಷ್ಟವಶಾತ್, RR ನಂತಹ ಕ್ರಮಾವಳಿಗಳು ಪ್ರತಿಕ್ರಿಯೆ ಸಮಯವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ, ಆದರೆ
ಟರ್ನ್ಅರೌಂಡ್ ಸಮಯದ ಮೆಟ್ರಿಕ್ ಮೇಲೆ ಕೆಟ್ಟ ಪರಿಣಾಮ ಬೀರುತ್ತದೆ. ಆದ್ದರಿಂದ ನಮ್ಮ ಸಮಸ್ಯೆ: ಹೇಗೆ ವಿನ್ಯಾಸ ಮಾಡುವುದು
ಶೆಡ್ಯೂಲರ್ ಅದು ನಮ್ಮ ಅವಶ್ಯಕತೆಗಳನ್ನು ಪೂರೈಸುತ್ತದೆ ಮತ್ತು ಅದೇ ಸಮಯದಲ್ಲಿ ಏನೂ ತಿಳಿದಿಲ್ಲ
ಪ್ರಕ್ರಿಯೆಯ ಸ್ವರೂಪ, ಸಾಮಾನ್ಯವಾಗಿ? ಕಾರ್ಯಗಳ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಶೆಡ್ಯೂಲರ್ ಹೇಗೆ ಕಲಿಯಬಹುದು,
ಅದು ಯಾವುದನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ ಮತ್ತು ಆದ್ದರಿಂದ ಉತ್ತಮ ವೇಳಾಪಟ್ಟಿ ನಿರ್ಧಾರಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ?
ಸಮಸ್ಯೆಯ ಸಾರ: ಪರಿಪೂರ್ಣ ಜ್ಞಾನವಿಲ್ಲದೆ ಕಾರ್ಯಗಳ ಸೆಟ್ಟಿಂಗ್ ಅನ್ನು ಹೇಗೆ ಯೋಜಿಸುವುದು?
ಪ್ರತಿಕ್ರಿಯೆ ಸಮಯವನ್ನು ಏಕಕಾಲದಲ್ಲಿ ಕಡಿಮೆ ಮಾಡುವ ಶೆಡ್ಯೂಲರ್ ಅನ್ನು ಹೇಗೆ ವಿನ್ಯಾಸಗೊಳಿಸುವುದು
ಸಂವಾದಾತ್ಮಕ ಕಾರ್ಯಗಳಿಗಾಗಿ ಮತ್ತು ಅದೇ ಸಮಯದಲ್ಲಿ ತಿಳಿಯದೆ ತಿರುಗುವ ಸಮಯವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ
ಕಾರ್ಯವನ್ನು ನಿರ್ವಹಿಸುವ ಸಮಯದ ಜ್ಞಾನ?
ಗಮನಿಸಿ: ಹಿಂದಿನ ಘಟನೆಗಳಿಂದ ಕಲಿಯುವುದು
MLFQ ಸರತಿಯು ತರಬೇತಿ ಪಡೆದ ವ್ಯವಸ್ಥೆಯ ಅತ್ಯುತ್ತಮ ಉದಾಹರಣೆಯಾಗಿದೆ
ಭವಿಷ್ಯವನ್ನು ಊಹಿಸಲು ಹಿಂದಿನ ಘಟನೆಗಳು. ಅಂತಹ ವಿಧಾನಗಳು ಆಗಾಗ್ಗೆ
OS ನಲ್ಲಿ ಕಂಡುಬರುತ್ತದೆ (ಮತ್ತು ಶಾಖೆಗಳನ್ನು ಒಳಗೊಂಡಂತೆ ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನದಲ್ಲಿ ಅನೇಕ ಇತರ ಶಾಖೆಗಳು
ಹಾರ್ಡ್‌ವೇರ್ ಮುನ್ನೋಟಗಳು ಮತ್ತು ಕ್ಯಾಶಿಂಗ್ ಅಲ್ಗಾರಿದಮ್‌ಗಳು). ಇದೇ ರೀತಿಯ ಪ್ರವಾಸಗಳು
ಕಾರ್ಯಗಳು ವರ್ತನೆಯ ಹಂತಗಳನ್ನು ಹೊಂದಿರುವಾಗ ಪ್ರಚೋದಿಸುತ್ತದೆ ಮತ್ತು ಆದ್ದರಿಂದ ಊಹಿಸಬಹುದಾಗಿದೆ.
ಆದಾಗ್ಯೂ, ಈ ತಂತ್ರದೊಂದಿಗೆ ಒಬ್ಬರು ಜಾಗರೂಕರಾಗಿರಬೇಕು, ಏಕೆಂದರೆ ಭವಿಷ್ಯವಾಣಿಗಳು ತುಂಬಾ ಸುಲಭ.
ತಪ್ಪಾಗಿ ಹೊರಹೊಮ್ಮಬಹುದು ಮತ್ತು ವ್ಯವಸ್ಥೆಯು ಕೆಟ್ಟ ನಿರ್ಧಾರಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು ಕಾರಣವಾಗಬಹುದು
ಯಾವುದೇ ಜ್ಞಾನವಿಲ್ಲದೆ ಇರುತ್ತದೆ.
MLFQ: ಮೂಲ ನಿಯಮಗಳು
MLFQ ಅಲ್ಗಾರಿದಮ್ನ ಮೂಲ ನಿಯಮಗಳನ್ನು ಪರಿಗಣಿಸಿ. ಮತ್ತು ಈ ಅಲ್ಗಾರಿದಮ್ನ ಅನುಷ್ಠಾನಗಳು
ಹಲವಾರು ಇವೆ, ಮೂಲ ವಿಧಾನಗಳು ಹೋಲುತ್ತವೆ.
ನಾವು ಪರಿಗಣಿಸುವ ಅನುಷ್ಠಾನದಲ್ಲಿ, MLFQ ಹಲವಾರು ಹೊಂದಿರುತ್ತದೆ
ಪ್ರತ್ಯೇಕ ಸರತಿ ಸಾಲುಗಳು, ಪ್ರತಿಯೊಂದೂ ವಿಭಿನ್ನ ಆದ್ಯತೆಯನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಯಾವುದೇ ಸಮಯದಲ್ಲಿ,
ಕಾರ್ಯಗತಗೊಳಿಸಲು ಸಿದ್ಧವಾಗಿರುವ ಕಾರ್ಯವು ಅದೇ ಸರದಿಯಲ್ಲಿದೆ. MLFQ ಆದ್ಯತೆಗಳನ್ನು ಬಳಸುತ್ತದೆ,
ಮರಣದಂಡನೆಗಾಗಿ ಯಾವ ಕೆಲಸವನ್ನು ಚಲಾಯಿಸಬೇಕೆಂದು ನಿರ್ಧರಿಸಲು, ಅಂದರೆ. ಹೆಚ್ಚಿನ ಜೊತೆ ಕಾರ್ಯ
ಆದ್ಯತೆ (ಅತ್ಯಂತ ಆದ್ಯತೆಯೊಂದಿಗೆ ಸರದಿಯಲ್ಲಿನ ಕಾರ್ಯ) ಅನ್ನು ಮೊದಲಿಗೆ ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ
ಸಾಲು.
ಸಹಜವಾಗಿ, ನಿರ್ದಿಷ್ಟ ಸರದಿಯಲ್ಲಿ ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಕಾರ್ಯಗಳು ಇರಬಹುದು
ಆದ್ದರಿಂದ ಅವರು ಅದೇ ಆದ್ಯತೆಯನ್ನು ಹೊಂದಿರುತ್ತಾರೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಯಾಂತ್ರಿಕ ವ್ಯವಸ್ಥೆಯನ್ನು ಬಳಸಲಾಗುತ್ತದೆ
ಈ ಕಾರ್ಯಗಳ ನಡುವೆ ಉಡಾವಣಾ ಯೋಜನೆಗಾಗಿ RR.
ಆದ್ದರಿಂದ ನಾವು MLFQ ಗಾಗಿ ಎರಡು ಮೂಲಭೂತ ನಿಯಮಗಳನ್ನು ತಲುಪುತ್ತೇವೆ:
- ನಿಯಮ1: ಆದ್ಯತೆ(ಎ) > ಆದ್ಯತೆ(ಬಿ), ಟಾಸ್ಕ್ ಎ ರನ್ ಆಗುತ್ತದೆ (ಬಿ ಆಗುವುದಿಲ್ಲ)
- ನಿಯಮ2: ಆದ್ಯತೆ(A) = ಆದ್ಯತೆ(B), A&B ಅನ್ನು RR ಬಳಸಿ ಆರಂಭಿಸಿದರೆ
ಮೇಲಿನದನ್ನು ಆಧರಿಸಿ, MLFQ ಅನ್ನು ಯೋಜಿಸುವ ಪ್ರಮುಖ ಅಂಶಗಳು
ಆದ್ಯತೆಗಳಾಗಿವೆ. ಪ್ರತಿಯೊಂದಕ್ಕೂ ನಿಗದಿತ ಆದ್ಯತೆ ನೀಡುವ ಬದಲು
ಕಾರ್ಯ, ಗಮನಿಸಿದ ನಡವಳಿಕೆಯನ್ನು ಅವಲಂಬಿಸಿ MLFQ ತನ್ನ ಆದ್ಯತೆಯನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ.
ಉದಾಹರಣೆಗೆ, ಕೀಬೋರ್ಡ್ ಇನ್‌ಪುಟ್‌ಗಾಗಿ ಕಾಯುತ್ತಿರುವಾಗ ಒಂದು ಕಾರ್ಯವು ನಿರಂತರವಾಗಿ CPU ನಲ್ಲಿ ಬಿಟ್ಟರೆ,
MLFQ ಪ್ರಕ್ರಿಯೆಯ ಆದ್ಯತೆಯನ್ನು ಹೆಚ್ಚು ಇರಿಸುತ್ತದೆ ಏಕೆಂದರೆ ಅದು ಹೇಗೆ
ಸಂವಾದಾತ್ಮಕ ಪ್ರಕ್ರಿಯೆಯು ಕಾರ್ಯನಿರ್ವಹಿಸಬೇಕು. ಒಂದು ವೇಳೆ, ಇದಕ್ಕೆ ವಿರುದ್ಧವಾಗಿ, ಕಾರ್ಯವು ನಿರಂತರವಾಗಿ ಮತ್ತು
ದೀರ್ಘಕಾಲದವರೆಗೆ CPU ತೀವ್ರವಾಗಿರುತ್ತದೆ, MLFQ ಅದನ್ನು ಡೌನ್‌ಗ್ರೇಡ್ ಮಾಡುತ್ತದೆ
ಒಂದು ಆದ್ಯತೆ. ಹೀಗಾಗಿ, MLFQ ಅವರು ಚಾಲನೆಯಲ್ಲಿರುವ ಸಮಯದಲ್ಲಿ ಪ್ರಕ್ರಿಯೆಗಳ ನಡವಳಿಕೆಯನ್ನು ಅಧ್ಯಯನ ಮಾಡುತ್ತದೆ.
ಮತ್ತು ನಡವಳಿಕೆಗಳನ್ನು ಬಳಸಿ.
ಕೆಲವು ಹಂತದಲ್ಲಿ ಸಾಲುಗಳು ಹೇಗಿರಬಹುದು ಎಂಬುದಕ್ಕೆ ಒಂದು ಉದಾಹರಣೆಯನ್ನು ಸೆಳೆಯೋಣ
ಸಮಯ ಮತ್ತು ನಂತರ ನೀವು ಈ ರೀತಿಯದನ್ನು ಪಡೆಯುತ್ತೀರಿ:
ಈ ಯೋಜನೆಯಲ್ಲಿ, 2 ಪ್ರಕ್ರಿಯೆಗಳು A ಮತ್ತು B ಹೆಚ್ಚಿನ ಆದ್ಯತೆಯೊಂದಿಗೆ ಸರದಿಯಲ್ಲಿವೆ. ಪ್ರಕ್ರಿಯೆ
C ಎಲ್ಲೋ ಮಧ್ಯದಲ್ಲಿದೆ, ಮತ್ತು ಪ್ರಕ್ರಿಯೆ D ಕ್ಯೂನ ಕೊನೆಯಲ್ಲಿದೆ. ಮೇಲಿನ ಪ್ರಕಾರ
MLFQ ಅಲ್ಗಾರಿದಮ್ನ ವಿವರಣೆಗಳು, ಶೆಡ್ಯೂಲರ್ ಹೆಚ್ಚಿನ ಕಾರ್ಯಗಳನ್ನು ಮಾತ್ರ ನಿರ್ವಹಿಸುತ್ತದೆ
RR ಪ್ರಕಾರ ಆದ್ಯತೆ ಮತ್ತು C, D ಕಾರ್ಯಗಳು ಕೆಲಸದಿಂದ ಹೊರಗುಳಿಯುತ್ತವೆ.
ಸ್ವಾಭಾವಿಕವಾಗಿ, ಒಂದು ಸ್ಥಿರ ಸ್ನ್ಯಾಪ್‌ಶಾಟ್ MLFQ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದರ ಸಂಪೂರ್ಣ ಚಿತ್ರವನ್ನು ನೀಡುವುದಿಲ್ಲ.
ಕಾಲಾನಂತರದಲ್ಲಿ ಚಿತ್ರವು ಹೇಗೆ ಬದಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಬಹಳ ಮುಖ್ಯ.
ಪ್ರಯತ್ನ 1: ಆದ್ಯತೆಯನ್ನು ಹೇಗೆ ಬದಲಾಯಿಸುವುದು
ಈ ಹಂತದಲ್ಲಿ, MLFQ ಆದ್ಯತೆಯ ಮಟ್ಟವನ್ನು ಹೇಗೆ ಬದಲಾಯಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನೀವು ನಿರ್ಧರಿಸಬೇಕು
ಕಾರ್ಯ (ಮತ್ತು ಸರದಿಯಲ್ಲಿ ಕಾರ್ಯದ ಸ್ಥಾನ) ಅದರ ಜೀವನ ಚಕ್ರದಲ್ಲಿ. ಫಾರ್
ಇದರಲ್ಲಿ, ನೀವು ಕೆಲಸದ ಹರಿವನ್ನು ನೆನಪಿನಲ್ಲಿಟ್ಟುಕೊಳ್ಳಬೇಕು: ನಿರ್ದಿಷ್ಟ ಮೊತ್ತ
ಕಡಿಮೆ ಚಾಲನೆಯಲ್ಲಿರುವ ಸಮಯದೊಂದಿಗೆ ಸಂವಾದಾತ್ಮಕ ಕಾರ್ಯಗಳು (ಮತ್ತು ಆಗಾಗ್ಗೆ ಬಿಡುಗಡೆ
CPU) ಮತ್ತು CPU ಅನ್ನು ತಮ್ಮ ಎಲ್ಲಾ ಕೆಲಸದ ಸಮಯವನ್ನು ಬಳಸುವ ಹಲವಾರು ದೀರ್ಘ ಕಾರ್ಯಗಳು
ಅಂತಹ ಕಾರ್ಯಗಳಿಗೆ ಪ್ರತಿಕ್ರಿಯೆ ಸಮಯವು ಮುಖ್ಯವಲ್ಲ. ಮತ್ತು ಆದ್ದರಿಂದ ನೀವು ಮೊದಲ ಪ್ರಯತ್ನವನ್ನು ಮಾಡಬಹುದು
ಕೆಳಗಿನ ನಿಯಮಗಳೊಂದಿಗೆ MLFQ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ:
- ನಿಯಮ 3: ಒಂದು ಕಾರ್ಯವು ಸಿಸ್ಟಮ್‌ಗೆ ಪ್ರವೇಶಿಸಿದಾಗ, ಅದನ್ನು ಅತ್ಯಧಿಕ ಸರದಿಯಲ್ಲಿ ಇರಿಸಲಾಗುತ್ತದೆ
- ಆದ್ಯತೆ.
- ರೂಲ್ 4 ಎ: ಒಂದು ಕಾರ್ಯವು ಅದರ ಸಂಪೂರ್ಣ ಸಮಯದ ವಿಂಡೋವನ್ನು ಬಳಸಿದರೆ, ಅದು
- ಆದ್ಯತೆಯನ್ನು ಕಡಿಮೆ ಮಾಡಲಾಗಿದೆ.
- ರೂಲ್ 4 ಬಿ: ಒಂದು ಕಾರ್ಯವು ಅದರ ಸಮಯ ವಿಂಡೋ ಅವಧಿ ಮುಗಿಯುವ ಮೊದಲು CPU ಅನ್ನು ಬಿಡುಗಡೆ ಮಾಡಿದರೆ, ಅದು
- ಅದೇ ಆದ್ಯತೆಯೊಂದಿಗೆ ಉಳಿದಿದೆ.
ಉದಾಹರಣೆ 1: ಏಕ ದೀರ್ಘಾವಧಿಯ ಕಾರ್ಯ
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ ನೀವು ನೋಡುವಂತೆ, ಪ್ರವೇಶದ ಕಾರ್ಯವನ್ನು ಅತ್ಯಧಿಕವಾಗಿ ಹೊಂದಿಸಲಾಗಿದೆ
ಆದ್ಯತೆ. 10ms ಸಮಯದ ವಿಂಡೋದ ನಂತರ, ಪ್ರಕ್ರಿಯೆಯನ್ನು ಆದ್ಯತೆಯಲ್ಲಿ ಡೌನ್‌ಗ್ರೇಡ್ ಮಾಡಲಾಗಿದೆ.
ಶೆಡ್ಯೂಲರ್. ಮುಂದಿನ ಬಾರಿ ವಿಂಡೋದ ನಂತರ, ಕಾರ್ಯವನ್ನು ಅಂತಿಮವಾಗಿ ಡೌನ್‌ಗ್ರೇಡ್ ಮಾಡಲಾಗಿದೆ
ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಕಡಿಮೆ ಆದ್ಯತೆ, ಅದು ಉಳಿದಿದೆ.
ಉದಾಹರಣೆ 2: ಚಿಕ್ಕ ಕಾರ್ಯವನ್ನು ಆಯ್ಕೆಮಾಡಲಾಗಿದೆ
ಈಗ MLFQ SJF ಅನ್ನು ಹೇಗೆ ಸಂಪರ್ಕಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ ಎಂಬುದರ ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ. ಅದರಲ್ಲಿ
ಉದಾಹರಣೆಗೆ, ಎರಡು ಕಾರ್ಯಗಳು: A, ಇದು ನಿರಂತರವಾಗಿ ದೀರ್ಘಾವಧಿಯ ಕಾರ್ಯವಾಗಿದೆ
CPU ಮತ್ತು B ಅನ್ನು ಆಕ್ರಮಿಸಿಕೊಳ್ಳುವುದು, ಇದು ಒಂದು ಸಣ್ಣ ಸಂವಾದಾತ್ಮಕ ಕಾರ್ಯವಾಗಿದೆ. ಊಹಿಸಿಕೊಳ್ಳಿ
ಟಾಸ್ಕ್ ಬಿ ತಲುಪುವ ವೇಳೆಗೆ ಎ ಈಗಾಗಲೇ ಸ್ವಲ್ಪ ಸಮಯ ಓಡುತ್ತಿತ್ತು.
ಈ ಗ್ರಾಫ್ ಸನ್ನಿವೇಶದ ಫಲಿತಾಂಶಗಳನ್ನು ತೋರಿಸುತ್ತದೆ. ಕಾರ್ಯ ಎ, ಯಾವುದೇ ಕಾರ್ಯದಂತೆ,
CPU ಅನ್ನು ಬಳಸುವುದು ಅತ್ಯಂತ ಕೆಳಭಾಗದಲ್ಲಿದೆ. ಕಾರ್ಯ B T=100 ಸಮಯಕ್ಕೆ ಬರುತ್ತದೆ ಮತ್ತು ಆಗುತ್ತದೆ
ಹೆಚ್ಚಿನ ಆದ್ಯತೆಯ ಸಾಲಿನಲ್ಲಿ ಇರಿಸಲಾಗಿದೆ. ಚಾಲನೆಯಲ್ಲಿರುವ ಸಮಯ ಕಡಿಮೆ ಇರುವುದರಿಂದ,
ಇದು ಕೊನೆಯ ಸರತಿಯನ್ನು ತಲುಪುವ ಮೊದಲು ಪೂರ್ಣಗೊಳ್ಳುತ್ತದೆ.
ಈ ಉದಾಹರಣೆಯಿಂದ, ಅಲ್ಗಾರಿದಮ್ನ ಮುಖ್ಯ ಗುರಿಯನ್ನು ನೀವು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕು: ಅಲ್ಗಾರಿದಮ್ ಇಲ್ಲವಾದ್ದರಿಂದ
ದೀರ್ಘವಾದ ಅಥವಾ ಚಿಕ್ಕದಾದ ಕೆಲಸವನ್ನು ತಿಳಿದಿದೆ, ನಂತರ ಅವನು ಮೊದಲು ಕಾರ್ಯವನ್ನು ಊಹಿಸುತ್ತಾನೆ
ಚಿಕ್ಕದಾಗಿದೆ ಮತ್ತು ಅದಕ್ಕೆ ಹೆಚ್ಚಿನ ಆದ್ಯತೆಯನ್ನು ನೀಡುತ್ತದೆ. ಇದು ನಿಜವಾಗಿಯೂ ಚಿಕ್ಕ ಕಾರ್ಯವಾಗಿದ್ದರೆ, ಆಗ
ಅದು ತ್ವರಿತವಾಗಿ ಕಾರ್ಯಗತಗೊಳ್ಳುತ್ತದೆ, ಇಲ್ಲದಿದ್ದರೆ ಅದು ದೀರ್ಘವಾದ ಕಾರ್ಯವಾಗಿದ್ದರೆ ಅದು ನಿಧಾನವಾಗಿ ಚಲಿಸುತ್ತದೆ
ಆದ್ಯತೆಯ ಕೆಳಗೆ ಮತ್ತು ಶೀಘ್ರದಲ್ಲೇ ಅವಳು ನಿಜವಾಗಿಯೂ ಮಾಡದ ದೀರ್ಘ ಕಾರ್ಯ ಎಂದು ಸಾಬೀತುಪಡಿಸುತ್ತದೆ
ಪ್ರತಿಕ್ರಿಯೆಯ ಅಗತ್ಯವಿದೆ.
ಉದಾಹರಣೆ 3: I/O ಬಗ್ಗೆ ಏನು?
ಈಗ I/O ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ. ನಿಯಮ 4b ನಲ್ಲಿ ಹೇಳಿರುವಂತೆ,
ಒಂದು ಪ್ರಕ್ರಿಯೆಯು ತನ್ನ ಪ್ರೊಸೆಸರ್ ಸಮಯವನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಬಳಸದೆಯೇ ಪ್ರೊಸೆಸರ್ ಅನ್ನು ಬಿಡುಗಡೆ ಮಾಡಿದರೆ,
ನಂತರ ಅದು ಅದೇ ಆದ್ಯತೆಯ ಮಟ್ಟದಲ್ಲಿ ಉಳಿಯುತ್ತದೆ. ಈ ನಿಯಮದ ಉದ್ದೇಶವು ತುಂಬಾ ಸರಳವಾಗಿದೆ.
- ಸಂವಾದಾತ್ಮಕ ಕೆಲಸವು ಬಹಳಷ್ಟು I/O ಅನ್ನು ನಿರ್ವಹಿಸಿದರೆ, ಉದಾಹರಣೆಗೆ, ಕಾಯುತ್ತಿದೆ
ಬಳಕೆದಾರರ ಕೀಸ್ಟ್ರೋಕ್‌ಗಳು ಅಥವಾ ಮೌಸ್‌ನಿಂದ, ಅಂತಹ ಕಾರ್ಯವು ಪ್ರೊಸೆಸರ್ ಅನ್ನು ಮುಕ್ತಗೊಳಿಸುತ್ತದೆ
ನಿಗದಿಪಡಿಸಿದ ವಿಂಡೋದ ಮೊದಲು. ಅಂತಹ ಆದ್ಯತೆಯ ಕೆಲಸವನ್ನು ಬಿಟ್ಟುಬಿಡಲು ನಾವು ಬಯಸುವುದಿಲ್ಲ,
ಹೀಗಾಗಿ ಅದು ಅದೇ ಮಟ್ಟದಲ್ಲಿ ಉಳಿಯುತ್ತದೆ.
ಅಂತಹ ಪ್ರಕ್ರಿಯೆಗಳೊಂದಿಗೆ ಅಲ್ಗಾರಿದಮ್ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಈ ಉದಾಹರಣೆ ತೋರಿಸುತ್ತದೆ - ಸಂವಾದಾತ್ಮಕ ಕಾರ್ಯ B, ಇದು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಮೊದಲು 1ms ಗೆ ಮಾತ್ರ CPU ಅಗತ್ಯವಿದೆ
I/O ಪ್ರಕ್ರಿಯೆ ಮತ್ತು ದೀರ್ಘವಾದ ಕೆಲಸ A, ಇದು CPU ಅನ್ನು ಎಲ್ಲಾ ಸಮಯದಲ್ಲೂ ಬಳಸುತ್ತದೆ.
MLFQ ಪ್ರಕ್ರಿಯೆ B ಅನ್ನು ಹೆಚ್ಚಿನ ಆದ್ಯತೆಯಲ್ಲಿ ಇರಿಸುತ್ತದೆ
CPU ಅನ್ನು ಬಿಡುಗಡೆ ಮಾಡಿ. ಬಿ ಸಂವಾದಾತ್ಮಕ ಕಾರ್ಯವಾಗಿದ್ದರೆ, ಈ ಸಂದರ್ಭದಲ್ಲಿ ಅಲ್ಗಾರಿದಮ್ ತಲುಪಿದೆ
ಸಂವಾದಾತ್ಮಕ ಕಾರ್ಯಗಳನ್ನು ತ್ವರಿತವಾಗಿ ಪ್ರಾರಂಭಿಸುವುದು ಇದರ ಉದ್ದೇಶವಾಗಿದೆ.
ಪ್ರಸ್ತುತ MLFQ ಅಲ್ಗಾರಿದಮ್‌ನೊಂದಿಗೆ ತೊಂದರೆಗಳು
ಹಿಂದಿನ ಉದಾಹರಣೆಗಳಲ್ಲಿ, ನಾವು MLFQ ನ ಮೂಲ ಆವೃತ್ತಿಯನ್ನು ನಿರ್ಮಿಸಿದ್ದೇವೆ. ಮತ್ತು ಅವನು ಎಂದು ತೋರುತ್ತದೆ
ಅದರ ಕೆಲಸವನ್ನು ಚೆನ್ನಾಗಿ ಮತ್ತು ನ್ಯಾಯಯುತವಾಗಿ ಮಾಡುತ್ತದೆ, CPU ಸಮಯವನ್ನು ತಕ್ಕಮಟ್ಟಿಗೆ ನಡುವೆ ವಿತರಿಸುತ್ತದೆ
ದೀರ್ಘ ಕಾರ್ಯಗಳು ಮತ್ತು ಚಿಕ್ಕ ಕಾರ್ಯಗಳು ಅಥವಾ ಅತೀವವಾಗಿ ಪ್ರವೇಶಿಸುವ ಕಾರ್ಯಗಳನ್ನು ಅನುಮತಿಸುವುದು
ತ್ವರಿತವಾಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು I/O ಗೆ. ದುರದೃಷ್ಟವಶಾತ್, ಈ ವಿಧಾನವು ಹಲವಾರು ಒಳಗೊಂಡಿದೆ
ಗಂಭೀರ ಸಮಸ್ಯೆಗಳು.
ಮೊದಲನೆಯದಾಗಿ, ಹಸಿವಿನ ಸಮಸ್ಯೆ: ವ್ಯವಸ್ಥೆಯು ಅನೇಕ ಸಂವಾದಾತ್ಮಕತೆಯನ್ನು ಹೊಂದಿದ್ದರೆ
ಕಾರ್ಯಗಳು, ಅವರು ಎಲ್ಲಾ CPU ಸಮಯವನ್ನು ಬಳಸುತ್ತಾರೆ ಮತ್ತು ಆದ್ದರಿಂದ ಒಂದೇ ಒಂದು ದೀರ್ಘಾವಧಿಯಲ್ಲ
ಕಾರ್ಯವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಅವಕಾಶ ಸಿಗುವುದಿಲ್ಲ (ಅವರು ಹಸಿವಿನಿಂದ ಬಳಲುತ್ತಿದ್ದಾರೆ).
ಎರಡನೆಯದಾಗಿ, ಸ್ಮಾರ್ಟ್ ಬಳಕೆದಾರರು ತಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ಬರೆಯಬಹುದು
ಶೆಡ್ಯೂಲರ್ ಅನ್ನು ಮರುಳು ಮಾಡಿ. ಬಲವಂತಕ್ಕಾಗಿ ಏನನ್ನಾದರೂ ಮಾಡುವುದರಲ್ಲಿ ಮೋಸ ಅಡಗಿದೆ
ಪ್ರಕ್ರಿಯೆಗೆ ಹೆಚ್ಚು CPU ಸಮಯವನ್ನು ನೀಡಲು ಶೆಡ್ಯೂಲರ್. ಅಲ್ಗಾರಿದಮ್ ಅದು
ಮೇಲೆ ವಿವರಿಸಿದ ಇಂತಹ ದಾಳಿಗಳಿಗೆ ಸಾಕಷ್ಟು ದುರ್ಬಲವಾಗಿದೆ: ಸಮಯ ವಿಂಡೋ ಪ್ರಾಯೋಗಿಕವಾಗಿ ಮೊದಲು
ಮೇಲೆ, ನೀವು I / O ಕಾರ್ಯಾಚರಣೆಯನ್ನು ನಿರ್ವಹಿಸಬೇಕಾಗಿದೆ (ಕೆಲವರಿಗೆ, ಯಾವ ಫೈಲ್ ಆಗಿರಲಿ)
ಮತ್ತು ಹೀಗೆ CPU ಅನ್ನು ಮುಕ್ತಗೊಳಿಸಿ. ಅಂತಹ ನಡವಳಿಕೆಯು ನಿಮ್ಮನ್ನು ಒಂದೇ ರೀತಿಯಲ್ಲಿ ಉಳಿಯಲು ಅನುಮತಿಸುತ್ತದೆ
ಸರದಿಯು ಸ್ವತಃ ಮತ್ತು ಮತ್ತೆ ಹೆಚ್ಚಿನ ಶೇಕಡಾವಾರು CPU ಸಮಯವನ್ನು ಪಡೆಯುತ್ತದೆ. ಮಾಡಿದರೆ
ಇದು ಸರಿಯಾಗಿದೆ (ಉದಾ. CPU ಅನ್ನು ಬಿಡುಗಡೆ ಮಾಡುವ ಮೊದಲು ವಿಂಡೋ ಸಮಯದ 99% ರನ್ ಮಾಡಿ),
ಅಂತಹ ಕಾರ್ಯವು ಪ್ರೊಸೆಸರ್ ಅನ್ನು ಸರಳವಾಗಿ ಏಕಸ್ವಾಮ್ಯಗೊಳಿಸುತ್ತದೆ.
ಅಂತಿಮವಾಗಿ, ಪ್ರೋಗ್ರಾಂ ಕಾಲಾನಂತರದಲ್ಲಿ ಅದರ ನಡವಳಿಕೆಯನ್ನು ಬದಲಾಯಿಸಬಹುದು. ಆ ಕಾರ್ಯಗಳು
ಬಳಸಿದ CPU ಸಂವಾದಾತ್ಮಕವಾಗಬಹುದು. ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ಹೋಲುತ್ತದೆ
ಕಾರ್ಯಗಳು ಇತರರಂತೆ ಶೆಡ್ಯೂಲರ್‌ನಿಂದ ಸರಿಯಾದ ಚಿಕಿತ್ಸೆಯನ್ನು ಪಡೆಯುವುದಿಲ್ಲ
(ಮೂಲ) ಸಂವಾದಾತ್ಮಕ ಕಾರ್ಯಗಳು.
ಪ್ರೇಕ್ಷಕರಿಗೆ ಪ್ರಶ್ನೆ: ಆಧುನಿಕ ಜಗತ್ತಿನಲ್ಲಿ ಶೆಡ್ಯೂಲರ್ ಮೇಲೆ ಯಾವ ದಾಳಿಗಳನ್ನು ಮಾಡಬಹುದು?
ಪ್ರಯತ್ನ 2: ಆದ್ಯತೆಯನ್ನು ಹೆಚ್ಚಿಸಿ
ನಿಯಮಗಳನ್ನು ಬದಲಾಯಿಸಲು ಪ್ರಯತ್ನಿಸೋಣ ಮತ್ತು ನಾವು ಸಮಸ್ಯೆಗಳನ್ನು ತಪ್ಪಿಸಬಹುದೇ ಎಂದು ನೋಡೋಣ
ಹಸಿವು. ಸಂಬಂಧಿಸಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನಾವು ಏನು ಮಾಡಬಹುದು
CPU ಕಾರ್ಯಗಳು ತಮ್ಮ ಸಮಯವನ್ನು ಪಡೆಯುತ್ತವೆ (ದೀರ್ಘವಾಗಿರದಿದ್ದರೂ ಸಹ).
ಸಮಸ್ಯೆಗೆ ಸರಳ ಪರಿಹಾರವಾಗಿ, ನೀವು ನಿಯತಕಾಲಿಕವಾಗಿ ಸೂಚಿಸಬಹುದು
ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಅಂತಹ ಎಲ್ಲಾ ಕಾರ್ಯಗಳ ಆದ್ಯತೆಯನ್ನು ಹೆಚ್ಚಿಸಿ. ಹಲವು ಮಾರ್ಗಗಳಿವೆ
ಇದನ್ನು ಸಾಧಿಸಲು, ಉದಾಹರಣೆಯಾಗಿ ಸರಳವಾದದ್ದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಪ್ರಯತ್ನಿಸೋಣ: ಅನುವಾದಿಸಿ
ಎಲ್ಲಾ ಕಾರ್ಯಗಳನ್ನು ಏಕಕಾಲದಲ್ಲಿ ಹೆಚ್ಚಿನ ಆದ್ಯತೆಗೆ, ಆದ್ದರಿಂದ ಹೊಸ ನಿಯಮ:
- ನಿಯಮ 5: ಕೆಲವು ಅವಧಿಯ ನಂತರ S, ಸಿಸ್ಟಮ್‌ನಲ್ಲಿನ ಎಲ್ಲಾ ಕಾರ್ಯಗಳನ್ನು ಹೆಚ್ಚಿನ ಸರತಿಗೆ ವರ್ಗಾಯಿಸಿ.
ನಮ್ಮ ಹೊಸ ನಿಯಮವು ಎರಡು ಸಮಸ್ಯೆಗಳನ್ನು ಏಕಕಾಲದಲ್ಲಿ ಪರಿಹರಿಸುತ್ತದೆ. ಮೊದಲನೆಯದಾಗಿ, ಪ್ರಕ್ರಿಯೆಗಳು
ಹಸಿವಿನಿಂದ ಬಳಲುವುದಿಲ್ಲ ಎಂದು ಖಾತರಿಪಡಿಸಲಾಗಿದೆ: ಹೆಚ್ಚಿನ ಸರದಿಯಲ್ಲಿರುವ ಕಾರ್ಯಗಳನ್ನು ಹಂಚಿಕೊಳ್ಳಲಾಗುತ್ತದೆ
RR ಅಲ್ಗಾರಿದಮ್ ಪ್ರಕಾರ ಪ್ರೊಸೆಸರ್ ಸಮಯ ಮತ್ತು ಹೀಗೆ ಎಲ್ಲಾ ಪ್ರಕ್ರಿಯೆಗಳು ಸ್ವೀಕರಿಸುತ್ತವೆ
ಪ್ರೊಸೆಸರ್ ಸಮಯ. ಎರಡನೆಯದಾಗಿ, ಹಿಂದೆ ಬಳಸಿದ ಕೆಲವು ಪ್ರಕ್ರಿಯೆಗಳು
ಪ್ರೊಸೆಸರ್ ಮಾತ್ರ ಸಂವಾದಾತ್ಮಕವಾಗುತ್ತದೆ, ಅದು ಅತ್ಯಧಿಕ ಸರದಿಯಲ್ಲಿ ಉಳಿಯುತ್ತದೆ
ಒಮ್ಮೆ ಹೆಚ್ಚಿನ ಆದ್ಯತೆಗೆ ವರ್ಧಕವನ್ನು ಪಡೆದ ನಂತರ ಆದ್ಯತೆ.
ಒಂದು ಉದಾಹರಣೆಯನ್ನು ಪರಿಗಣಿಸಿ. ಈ ಸನ್ನಿವೇಶದಲ್ಲಿ, ಬಳಸುವ ಏಕೈಕ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪರಿಗಣಿಸಿ
CPU ಮತ್ತು ಎರಡು ಸಂವಾದಾತ್ಮಕ, ಸಣ್ಣ ಪ್ರಕ್ರಿಯೆಗಳು. ಚಿತ್ರದಲ್ಲಿನ ಎಡಭಾಗದಲ್ಲಿ, ಆಕೃತಿಯು ಆದ್ಯತೆಯ ವರ್ಧಕವಿಲ್ಲದೆ ನಡವಳಿಕೆಯನ್ನು ತೋರಿಸುತ್ತದೆ ಮತ್ತು ಹೀಗೆ ಎರಡು ಸಂವಾದಾತ್ಮಕ ಕಾರ್ಯಗಳು ಸಿಸ್ಟಮ್‌ಗೆ ಬಂದ ನಂತರ ದೀರ್ಘಾವಧಿಯ ಕಾರ್ಯವು ಹಸಿವಿನಿಂದ ಬಳಲುತ್ತದೆ. ಬಲಭಾಗದಲ್ಲಿರುವ ಚಿತ್ರದಲ್ಲಿ, ಪ್ರತಿ 50ms ಗೆ ಆದ್ಯತೆಯ ಹೆಚ್ಚಳವನ್ನು ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಹೀಗಾಗಿ ಎಲ್ಲಾ ಪ್ರಕ್ರಿಯೆಗಳು ಪ್ರೊಸೆಸರ್ ಸಮಯವನ್ನು ಸ್ವೀಕರಿಸಲು ಖಾತರಿಪಡಿಸುತ್ತದೆ ಮತ್ತು ನಿಯತಕಾಲಿಕವಾಗಿ ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ 50ms ಅನ್ನು ಉದಾಹರಣೆಯಾಗಿ ತೆಗೆದುಕೊಳ್ಳಲಾಗುತ್ತದೆ, ವಾಸ್ತವದಲ್ಲಿ ಈ ಸಂಖ್ಯೆ ಸ್ವಲ್ಪ ಹೆಚ್ಚಾಗಿದೆ.
ಆವರ್ತಕ ಏರಿಕೆ ಸಮಯ S ನ ಸೇರ್ಪಡೆಯು ಕಾರಣವಾಗುತ್ತದೆ ಎಂಬುದು ಸ್ಪಷ್ಟವಾಗಿದೆ
ತಾರ್ಕಿಕ ಪ್ರಶ್ನೆ: ಯಾವ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿಸಬೇಕು? ಅರ್ಹರಲ್ಲಿ ಒಬ್ಬರು
ಸಿಸ್ಟಮ್ಸ್ ಇಂಜಿನಿಯರ್‌ಗಳಾದ ಜಾನ್ ಓಸ್ಟರ್‌ಹೌಟ್ ಸಿಸ್ಟಮ್‌ಗಳಲ್ಲಿ ಒಂದೇ ರೀತಿಯ ಪ್ರಮಾಣಗಳನ್ನು ವೂ-ಡೂ ಎಂದು ಉಲ್ಲೇಖಿಸಿದ್ದಾರೆ
ಸ್ಥಿರ, ಏಕೆಂದರೆ ಅವರು ಕೆಲವು ರೀತಿಯಲ್ಲಿ ಸರಿಯಾದ ಕಪ್ಪು ಮ್ಯಾಜಿಕ್ ಅಗತ್ಯವಿದೆ
ಒಡ್ಡುವಿಕೆ. ಮತ್ತು, ದುರದೃಷ್ಟವಶಾತ್, ಎಸ್ ಅಂತಹ ಪರಿಮಳವನ್ನು ಹೊಂದಿದೆ. ನೀವು ಮೌಲ್ಯವನ್ನು ಸಹ ಹೊಂದಿಸಿದರೆ
ದೊಡ್ಡ - ದೀರ್ಘ ಕಾರ್ಯಗಳು ಹಸಿವಿನಿಂದ ಬಳಲುತ್ತವೆ. ಮತ್ತು ನೀವು ಅದನ್ನು ತುಂಬಾ ಕಡಿಮೆ ಹೊಂದಿಸಿದರೆ,
ಸಂವಾದಾತ್ಮಕ ಕಾರ್ಯಗಳು ಸರಿಯಾದ CPU ಸಮಯವನ್ನು ಸ್ವೀಕರಿಸುವುದಿಲ್ಲ.
ಪ್ರಯತ್ನ 3: ಉತ್ತಮ ಲೆಕ್ಕಪತ್ರ ನಿರ್ವಹಣೆ
ಈಗ ನಾವು ಇನ್ನೂ ಒಂದು ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಬೇಕಾಗಿದೆ: ಹೇಗೆ ಮಾಡಬಾರದು
ನಮ್ಮ ಶೆಡ್ಯೂಲರನ್ನು ಮೋಸ ಮಾಡಲು ಅನುಮತಿಸುವುದೇ? ಈ ಸಾಧ್ಯತೆಗೆ ಕಾರಣಕರ್ತರು
ನಿಯಮಗಳು 4a, 4b ಪ್ರೊಸೆಸರ್ ಅನ್ನು ಮುಕ್ತಗೊಳಿಸುವ ಮೂಲಕ ಕೆಲಸವು ತನ್ನ ಆದ್ಯತೆಯನ್ನು ಉಳಿಸಿಕೊಳ್ಳಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ
ನಿಗದಿಪಡಿಸಿದ ಸಮಯದ ಮುಕ್ತಾಯದ ಮೊದಲು. ಅದನ್ನು ನಿಭಾಯಿಸುವುದು ಹೇಗೆ?
ಈ ಸಂದರ್ಭದಲ್ಲಿ ಪರಿಹಾರವನ್ನು ಪ್ರತಿಯೊಂದರಲ್ಲೂ CPU ಸಮಯದ ಉತ್ತಮ ಲೆಕ್ಕಪರಿಶೋಧನೆ ಎಂದು ಪರಿಗಣಿಸಬಹುದು
MLFQ ಮಟ್ಟ. ಪ್ರೋಗ್ರಾಂ ಬಳಸಿದ ಸಮಯವನ್ನು ಮರೆತುಬಿಡುವ ಬದಲು
ನಿಗದಿಪಡಿಸಿದ ಮಧ್ಯಂತರಕ್ಕೆ ಪ್ರೊಸೆಸರ್, ನೀವು ಗಣನೆಗೆ ತೆಗೆದುಕೊಂಡು ಅದನ್ನು ಉಳಿಸಬೇಕು. ನಂತರ
ಪ್ರಕ್ರಿಯೆಯು ತನ್ನ ನಿಗದಿಪಡಿಸಿದ ಸಮಯವನ್ನು ಬಳಸಿಕೊಂಡಿದೆ, ಅದನ್ನು ಮುಂದಿನದಕ್ಕೆ ಕೆಳಗಿಳಿಸಬೇಕು
ಆದ್ಯತೆಯ ಮಟ್ಟ. ಪ್ರಕ್ರಿಯೆಯು ತನ್ನ ಸಮಯವನ್ನು ಹೇಗೆ ಬಳಸುತ್ತದೆ ಎಂಬುದು ಈಗ ವಿಷಯವಲ್ಲ - ಹೇಗೆ
ಪ್ರೊಸೆಸರ್‌ನಲ್ಲಿ ಅಥವಾ ಕರೆಗಳ ಗುಂಪಾಗಿ ನಿರಂತರವಾಗಿ ಕಂಪ್ಯೂಟಿಂಗ್. ಹೀಗಾಗಿ,
ನಿಯಮ 4 ಅನ್ನು ಈ ಕೆಳಗಿನಂತೆ ಪುನಃ ಬರೆಯಬೇಕು:
- ನಿಯಮ 4: ಒಂದು ಕಾರ್ಯವು ಪ್ರಸ್ತುತ ಸರದಿಯಲ್ಲಿ ನಿಗದಿಪಡಿಸಿದ ಸಮಯವನ್ನು ಬಳಸಿದ ನಂತರ (ಅದು ಎಷ್ಟು ಬಾರಿ CPU ಅನ್ನು ಮುಕ್ತಗೊಳಿಸಿದೆ ಎಂಬುದರ ಹೊರತಾಗಿಯೂ), ಅಂತಹ ಕಾರ್ಯದ ಆದ್ಯತೆಯು ಕಡಿಮೆಯಾಗುತ್ತದೆ (ಇದು ಸರದಿಯಲ್ಲಿ ಚಲಿಸುತ್ತದೆ).
ಒಂದು ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ:
»
ನೀವು ಶೆಡ್ಯೂಲರ್ ಅನ್ನು ಮೋಸಗೊಳಿಸಲು ಪ್ರಯತ್ನಿಸಿದರೆ ಏನಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಅಂಕಿ ತೋರಿಸುತ್ತದೆ
ಹಿಂದಿನ ನಿಯಮಗಳು 4a ನೊಂದಿಗೆ ಇದ್ದರೆ, 4b ಎಡಭಾಗದಲ್ಲಿ ಫಲಿತಾಂಶವಾಗಿರುತ್ತದೆ. ಹೊಸದರೊಂದಿಗೆ
ನಿಯಮವು ಫಲಿತಾಂಶವು ಬಲಭಾಗದಲ್ಲಿದೆ. ರಕ್ಷಣೆಗೆ ಮುಂಚಿತವಾಗಿ, ಯಾವುದೇ ಪ್ರಕ್ರಿಯೆಯು ಪೂರ್ಣಗೊಳ್ಳುವ ಮೊದಲು I/O ಅನ್ನು ಕರೆಯಬಹುದು ಮತ್ತು
ಆದ್ದರಿಂದ ವರ್ತನೆಯನ್ನು ಲೆಕ್ಕಿಸದೆ ರಕ್ಷಣೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿದ ನಂತರ CPU ಮೇಲೆ ಪ್ರಾಬಲ್ಯ ಸಾಧಿಸಿ
I/O, ಅವನು ಇನ್ನೂ ಸರದಿಯಲ್ಲಿ ಇಳಿಯುತ್ತಾನೆ ಮತ್ತು ಆದ್ದರಿಂದ ಅಪ್ರಾಮಾಣಿಕವಾಗಿ ಮಾಡಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ
CPU ಸಂಪನ್ಮೂಲಗಳನ್ನು ಸ್ವಾಧೀನಪಡಿಸಿಕೊಳ್ಳಿ.
MLFQ ಮತ್ತು ಇತರ ಸಮಸ್ಯೆಗಳನ್ನು ಸುಧಾರಿಸುವುದು
ಮೇಲಿನ ಸುಧಾರಣೆಗಳೊಂದಿಗೆ, ಹೊಸ ಸಮಸ್ಯೆಗಳು ಉದ್ಭವಿಸುತ್ತವೆ: ಮುಖ್ಯವಾದವುಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ
ಪ್ರಶ್ನೆಗಳು - ಅಂತಹ ಶೆಡ್ಯೂಲರ್ ಅನ್ನು ಪ್ಯಾರಾಮೀಟರ್ ಮಾಡುವುದು ಹೇಗೆ? ಆ. ಎಷ್ಟು ಇರಬೇಕು
ಸಾಲುಗಳು? ಸರದಿಯಲ್ಲಿ ಪ್ರೋಗ್ರಾಂ ವಿಂಡೋದ ಗಾತ್ರ ಹೇಗಿರಬೇಕು? ಹೇಗೆ
ಹಸಿವಿನಿಂದ ತಪ್ಪಿಸಿಕೊಳ್ಳಲು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಹೆಚ್ಚಾಗಿ ಆದ್ಯತೆ ನೀಡಬೇಕು ಮತ್ತು
ಕಾರ್ಯಕ್ರಮದ ನಡವಳಿಕೆಯಲ್ಲಿನ ಬದಲಾವಣೆಯನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳಲು? ಈ ಪ್ರಶ್ನೆಗಳಿಗೆ, ಯಾವುದೇ ಸರಳವಿಲ್ಲ
ಪ್ರತಿಕ್ರಿಯೆ ಮತ್ತು ಲೋಡ್‌ಗಳು ಮತ್ತು ನಂತರದ ಸಂರಚನೆಯೊಂದಿಗೆ ಮಾತ್ರ ಪ್ರಯೋಗಗಳು
ಶೆಡ್ಯೂಲರ್ ಕೆಲವು ತೃಪ್ತಿದಾಯಕ ಸಮತೋಲನಕ್ಕೆ ಕಾರಣವಾಗಬಹುದು.
ಉದಾಹರಣೆಗೆ, ಹೆಚ್ಚಿನ MLFQ ಅಳವಡಿಕೆಗಳು ವಿಭಿನ್ನವಾಗಿ ನಿಯೋಜಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ
ವಿವಿಧ ಸಾಲುಗಳಿಗಾಗಿ ಸಮಯ ಸ್ಲಾಟ್‌ಗಳು. ಹೆಚ್ಚಿನ ಆದ್ಯತೆಯ ಸಾಲುಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಇರುತ್ತವೆ
ಸಣ್ಣ ಮಧ್ಯಂತರಗಳು. ಈ ಸಾಲುಗಳು ಸಂವಾದಾತ್ಮಕ ಕಾರ್ಯಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ,
ಇದರ ನಡುವೆ ಬದಲಾಯಿಸುವುದು ಸಾಕಷ್ಟು ಸೂಕ್ಷ್ಮವಾಗಿರುತ್ತದೆ ಮತ್ತು 10 ಅಥವಾ ಕಡಿಮೆ ತೆಗೆದುಕೊಳ್ಳಬೇಕು
ms. ಇದಕ್ಕೆ ವ್ಯತಿರಿಕ್ತವಾಗಿ, ಕಡಿಮೆ-ಆದ್ಯತೆಯ ಸರತಿ ಸಾಲುಗಳು ದೀರ್ಘಾವಧಿಯ ಕಾರ್ಯಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ
CPU. ಮತ್ತು ಈ ಸಂದರ್ಭದಲ್ಲಿ, ದೀರ್ಘಾವಧಿಯ ಮಧ್ಯಂತರಗಳು ಚೆನ್ನಾಗಿ ಹೊಂದಿಕೊಳ್ಳುತ್ತವೆ (100ms).
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ಹೆಚ್ಚಿನ ಆದ್ಯತೆಯ ಕ್ಯೂ 2 ರಲ್ಲಿ ಕೆಲಸ ಮಾಡಿದ 20 ಕಾರ್ಯಗಳಿವೆ
ms ಅನ್ನು 10ms ವಿಂಡೋಗಳಾಗಿ ವಿಂಗಡಿಸಲಾಗಿದೆ. ಮಧ್ಯದ ಸರದಿಯಲ್ಲಿ (40ms ವಿಂಡೋ) ಮತ್ತು ಕಡಿಮೆ ಆದ್ಯತೆಯ ಸರದಿಯಲ್ಲಿ 20ms
ಕ್ಯೂ ಸಮಯ ವಿಂಡೋವು 40ms ಆಯಿತು, ಅಲ್ಲಿ ಕಾರ್ಯಗಳು ತಮ್ಮ ಕೆಲಸವನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದವು.
ಸೋಲಾರಿಸ್ OS ನಲ್ಲಿ MLFQ ನ ಅನುಷ್ಠಾನವು ಸಮಯ-ಹಂಚಿಕೆ ಶೆಡ್ಯೂಲರ್‌ಗಳ ವರ್ಗವಾಗಿದೆ.
ಶೆಡ್ಯೂಲರ್ ಟೇಬಲ್‌ಗಳ ಸೆಟ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ ಅದು ಹೇಗೆ ಬೇಕು ಎಂಬುದನ್ನು ನಿಖರವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ
ಅದರ ಜೀವನದ ಅವಧಿಯಲ್ಲಿ ಪ್ರಕ್ರಿಯೆಯ ಆದ್ಯತೆಯನ್ನು ಬದಲಾಯಿಸಿ, ಗಾತ್ರ ಹೇಗಿರಬೇಕು
ವಿಂಡೊವನ್ನು ಹಂಚಬೇಕು ಮತ್ತು ಕಾರ್ಯದ ಆದ್ಯತೆಗಳನ್ನು ಎಷ್ಟು ಬಾರಿ ಹೆಚ್ಚಿಸಬೇಕು. ನಿರ್ವಾಹಕ
ಸಿಸ್ಟಮ್ ಈ ಕೋಷ್ಟಕದೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಬಹುದು ಮತ್ತು ಶೆಡ್ಯೂಲರ್ ಅನ್ನು ವರ್ತಿಸುವಂತೆ ಮಾಡಬಹುದು
ವಿಭಿನ್ನವಾಗಿ. ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಈ ಕೋಷ್ಟಕವು ಕ್ರಮೇಣ ಹೆಚ್ಚಳದೊಂದಿಗೆ 60 ಸಾಲುಗಳನ್ನು ಹೊಂದಿದೆ
ವಿಂಡೋ ಗಾತ್ರ 20ms (ಹೆಚ್ಚಿನ ಆದ್ಯತೆ) ನಿಂದ ಹಲವಾರು ನೂರು ms ವರೆಗೆ (ಕಡಿಮೆ ಆದ್ಯತೆ), ಮತ್ತು
ಒಂದು ಸೆಕೆಂಡಿಗೆ ಒಮ್ಮೆ ಎಲ್ಲಾ ಕಾರ್ಯಗಳ ಉತ್ತೇಜನದೊಂದಿಗೆ.
ಇತರ MLFQ ಶೆಡ್ಯೂಲರ್‌ಗಳು ಟೇಬಲ್ ಅಥವಾ ಯಾವುದೇ ನಿರ್ದಿಷ್ಟವನ್ನು ಬಳಸುವುದಿಲ್ಲ
ಈ ಅಧ್ಯಾಯದಲ್ಲಿ ವಿವರಿಸಲಾದ ನಿಯಮಗಳು, ಇದಕ್ಕೆ ವಿರುದ್ಧವಾಗಿ, ಅವರು ಬಳಸಿಕೊಂಡು ಆದ್ಯತೆಗಳನ್ನು ಲೆಕ್ಕ ಹಾಕುತ್ತಾರೆ
ಗಣಿತದ ಸೂತ್ರಗಳು. ಉದಾಹರಣೆಗೆ, FreeBSD ನಲ್ಲಿ ಶೆಡ್ಯೂಲರ್ ಒಂದು ಸೂತ್ರವನ್ನು ಬಳಸುತ್ತದೆ
ಪ್ರಕ್ರಿಯೆ ಎಷ್ಟು ಎಂಬುದರ ಆಧಾರದ ಮೇಲೆ ಪ್ರಸ್ತುತ ಕಾರ್ಯದ ಆದ್ಯತೆಯನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು
CPU ಅನ್ನು ಬಳಸಲಾಗಿದೆ. ಜೊತೆಗೆ, CPU ಬಳಕೆಯು ಕಾಲಾನಂತರದಲ್ಲಿ ಕೊಳೆಯುತ್ತದೆ, ಮತ್ತು ಹೀಗೆ
ಹೀಗಾಗಿ, ಆದ್ಯತೆಯ ಹೆಚ್ಚಳವು ಮೇಲೆ ವಿವರಿಸಿದಕ್ಕಿಂತ ಸ್ವಲ್ಪ ಭಿನ್ನವಾಗಿದೆ. ಇದು ಸತ್ಯ
ಕೊಳೆತ ಅಲ್ಗಾರಿದಮ್ಸ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಆವೃತ್ತಿ 7.1 ರಂತೆ, FreeBSD ULE ಶೆಡ್ಯೂಲರ್ ಅನ್ನು ಬಳಸುತ್ತದೆ.
ಅಂತಿಮವಾಗಿ, ಅನೇಕ ಯೋಜಕರು ಇತರ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಹೊಂದಿದ್ದಾರೆ. ಉದಾಹರಣೆಗೆ, ಕೆಲವು
ಶೆಡ್ಯೂಲರ್‌ಗಳು ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂನ ಕಾರ್ಯಾಚರಣೆಗೆ ಹೆಚ್ಚಿನ ಮಟ್ಟವನ್ನು ಕಾಯ್ದಿರಿಸುತ್ತಾರೆ ಮತ್ತು ಹೀಗೆ
ಹೀಗಾಗಿ, ಯಾವುದೇ ಬಳಕೆದಾರ ಪ್ರಕ್ರಿಯೆಯು ಹೆಚ್ಚಿನ ಆದ್ಯತೆಯನ್ನು ಪಡೆಯಲು ಸಾಧ್ಯವಿಲ್ಲ
ವ್ಯವಸ್ಥೆ. ಕೆಲವು ವ್ಯವಸ್ಥೆಗಳು ನಿಮಗೆ ಸಹಾಯ ಮಾಡಲು ಸಲಹೆ ನೀಡಲು ಅವಕಾಶ ಮಾಡಿಕೊಡುತ್ತವೆ
ಶೆಡ್ಯೂಲರ್ ಸರಿಯಾಗಿ ಆದ್ಯತೆ ನೀಡಲು. ಉದಾಹರಣೆಗೆ, ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ ಸಂತೋಷವನ್ನು
ನೀವು ಕಾರ್ಯದ ಆದ್ಯತೆಯನ್ನು ಹೆಚ್ಚಿಸಬಹುದು ಅಥವಾ ಕಡಿಮೆ ಮಾಡಬಹುದು ಮತ್ತು ಹೀಗೆ ಹೆಚ್ಚಿಸಬಹುದು ಅಥವಾ ಕಡಿಮೆ ಮಾಡಬಹುದು
CPU ಸಮಯಕ್ಕೆ ಪ್ರೋಗ್ರಾಂನ ಸಾಧ್ಯತೆಗಳನ್ನು ಕಡಿಮೆ ಮಾಡಿ.
MLFQ: ಸಾರಾಂಶ
MLFQ ಎಂಬ ಯೋಜನಾ ವಿಧಾನವನ್ನು ನಾವು ವಿವರಿಸಿದ್ದೇವೆ. ಅವನ ಹೆಸರು
ಕಾರ್ಯಾಚರಣೆಯ ತತ್ವದಲ್ಲಿ ತೀರ್ಮಾನಿಸಲಾಗಿದೆ - ಇದು ಹಲವಾರು ಸಾಲುಗಳನ್ನು ಹೊಂದಿದೆ ಮತ್ತು ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಬಳಸುತ್ತದೆ
ಒಂದು ಕಾರ್ಯಕ್ಕೆ ಆದ್ಯತೆ ನೀಡಲು.
ನಿಯಮಗಳ ಅಂತಿಮ ರೂಪವು ಈ ಕೆಳಗಿನಂತಿರುತ್ತದೆ:
- ನಿಯಮ 1: ಆದ್ಯತೆ(ಎ) > ಆದ್ಯತೆ(ಬಿ), ಟಾಸ್ಕ್ ಎ ರನ್ ಆಗುತ್ತದೆ (ಬಿ ಆಗುವುದಿಲ್ಲ)
- ನಿಯಮ 2: ಆದ್ಯತೆ(A) = ಆದ್ಯತೆ(B), A&B ಅನ್ನು RR ಬಳಸಿ ಪ್ರಾರಂಭಿಸಿದರೆ
- ನಿಯಮ 3: ಒಂದು ಕಾರ್ಯವು ಸಿಸ್ಟಮ್‌ಗೆ ಪ್ರವೇಶಿಸಿದಾಗ, ಅದನ್ನು ಹೆಚ್ಚಿನ ಆದ್ಯತೆಯ ಸರದಿಯಲ್ಲಿ ಇರಿಸಲಾಗುತ್ತದೆ.
- ನಿಯಮ 4: ಒಂದು ಕಾರ್ಯವು ಪ್ರಸ್ತುತ ಸರದಿಯಲ್ಲಿ ನಿಗದಿಪಡಿಸಿದ ಸಮಯವನ್ನು ಬಳಸಿದ ನಂತರ (ಅದು ಎಷ್ಟು ಬಾರಿ CPU ಅನ್ನು ಮುಕ್ತಗೊಳಿಸಿದೆ ಎಂಬುದರ ಹೊರತಾಗಿಯೂ), ಅಂತಹ ಕಾರ್ಯದ ಆದ್ಯತೆಯು ಕಡಿಮೆಯಾಗುತ್ತದೆ (ಇದು ಸರದಿಯಲ್ಲಿ ಚಲಿಸುತ್ತದೆ).
- ನಿಯಮ 5: ಕೆಲವು ಅವಧಿಯ ನಂತರ S, ಸಿಸ್ಟಮ್‌ನಲ್ಲಿನ ಎಲ್ಲಾ ಕಾರ್ಯಗಳನ್ನು ಹೆಚ್ಚಿನ ಸರತಿಗೆ ವರ್ಗಾಯಿಸಿ.
MLFQ ಕೆಳಗಿನ ಕಾರಣಕ್ಕಾಗಿ ಆಸಕ್ತಿದಾಯಕವಾಗಿದೆ - ಬದಲಿಗೆ ಜ್ಞಾನದ ಅವಶ್ಯಕತೆ ಇದೆ
ಕಾರ್ಯದ ಸ್ವರೂಪವನ್ನು ಮುಂಚಿತವಾಗಿ, ಅಲ್ಗಾರಿದಮ್ ಕಾರ್ಯದ ಹಿಂದಿನ ನಡವಳಿಕೆಯನ್ನು ಕಲಿಯುತ್ತದೆ ಮತ್ತು ಹೊಂದಿಸುತ್ತದೆ
ಅದಕ್ಕೆ ಅನುಗುಣವಾಗಿ ಆದ್ಯತೆಗಳು. ಹೀಗಾಗಿ, ಅವರು ಏಕಕಾಲದಲ್ಲಿ ಎರಡು ಕುರ್ಚಿಗಳ ಮೇಲೆ ಕುಳಿತುಕೊಳ್ಳಲು ಪ್ರಯತ್ನಿಸುತ್ತಾರೆ - ಸಣ್ಣ ಕಾರ್ಯಗಳಿಗೆ (SJF, STCF) ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸಾಧಿಸಲು ಮತ್ತು ಪ್ರಾಮಾಣಿಕವಾಗಿ ದೀರ್ಘವಾದವುಗಳನ್ನು ಚಲಾಯಿಸಲು,
CPU-ಲೋಡ್ ಮಾಡುವ ಕೆಲಸಗಳು. ಆದ್ದರಿಂದ, BSD ಮತ್ತು ಅವುಗಳ ಉತ್ಪನ್ನಗಳು ಸೇರಿದಂತೆ ಹಲವು ವ್ಯವಸ್ಥೆಗಳು,
ಸೋಲಾರಿಸ್, ವಿಂಡೋಸ್, ಮ್ಯಾಕ್ ಕೆಲವು ರೀತಿಯ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಶೆಡ್ಯೂಲರ್ ಆಗಿ ಬಳಸುತ್ತವೆ
MLFQ ಬೇಸ್‌ಲೈನ್‌ನಂತೆ.
Дополнительные:
- (ಕಂಪ್ಯೂಟಿಂಗ್)
ಮೂಲ: www.habr.com