ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂಗಳ ಪರಿಚಯ
ಹೇ ಹಬ್ರ್! ನನ್ನ ಅಭಿಪ್ರಾಯದಲ್ಲಿ ಒಂದು ಆಸಕ್ತಿದಾಯಕ ಸಾಹಿತ್ಯದ ಲೇಖನಗಳು-ಅನುವಾದಗಳ ಸರಣಿಯನ್ನು ನಿಮ್ಮ ಗಮನಕ್ಕೆ ತರಲು ನಾನು ಬಯಸುತ್ತೇನೆ - OSTEP. ಈ ವಸ್ತುವು ಯುನಿಕ್ಸ್ ತರಹದ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂಗಳ ಕೆಲಸವನ್ನು ಸಾಕಷ್ಟು ಆಳವಾಗಿ ಚರ್ಚಿಸುತ್ತದೆ, ಅವುಗಳೆಂದರೆ, ಪ್ರಕ್ರಿಯೆಗಳು, ವಿವಿಧ ಶೆಡ್ಯೂಲರ್‌ಗಳು, ಮೆಮೊರಿ ಮತ್ತು ಆಧುನಿಕ OS ಅನ್ನು ರೂಪಿಸುವ ಇತರ ರೀತಿಯ ಘಟಕಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ. ಎಲ್ಲಾ ವಸ್ತುಗಳ ಮೂಲವನ್ನು ನೀವು ಇಲ್ಲಿ ನೋಡಬಹುದು . ಅನುವಾದವನ್ನು ವೃತ್ತಿಪರವಲ್ಲದ (ಸಾಕಷ್ಟು ಮುಕ್ತವಾಗಿ) ಮಾಡಲಾಗಿದೆ ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ, ಆದರೆ ನಾನು ಸಾಮಾನ್ಯ ಅರ್ಥವನ್ನು ಉಳಿಸಿಕೊಂಡಿದ್ದೇನೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ.
ಈ ವಿಷಯದ ಕುರಿತು ಲ್ಯಾಬ್ ಕೆಲಸವನ್ನು ಇಲ್ಲಿ ಕಾಣಬಹುದು:
ಇತರ ಭಾಗಗಳು:
ನೀವು ನನ್ನ ಚಾನಲ್ ಅನ್ನು ಸಹ ಇಲ್ಲಿ ಪರಿಶೀಲಿಸಬಹುದು =)
ಶೆಡ್ಯೂಲರ್ ಪರಿಚಯ
ಸಮಸ್ಯೆಯ ಸಾರ: ಶೆಡ್ಯೂಲರ್ ನೀತಿಯನ್ನು ಹೇಗೆ ಅಭಿವೃದ್ಧಿಪಡಿಸುವುದು
ಆಧಾರವಾಗಿರುವ ಶೆಡ್ಯೂಲರ್ ನೀತಿ ಚೌಕಟ್ಟುಗಳನ್ನು ಹೇಗೆ ವಿನ್ಯಾಸಗೊಳಿಸಬೇಕು? ಪ್ರಮುಖ ಊಹೆಗಳು ಏನಾಗಿರಬೇಕು? ಯಾವ ಮೆಟ್ರಿಕ್‌ಗಳು ಮುಖ್ಯ? ಆರಂಭಿಕ ಕಂಪ್ಯೂಟಿಂಗ್ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ಯಾವ ಮೂಲಭೂತ ತಂತ್ರಗಳನ್ನು ಬಳಸಲಾಯಿತು?
ಕೆಲಸದ ಹೊರೆ ಊಹೆಗಳು
ಸಂಭವನೀಯ ನೀತಿಗಳನ್ನು ಚರ್ಚಿಸುವ ಮೊದಲು, ಸಿಸ್ಟಂನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಪ್ರಕ್ರಿಯೆಗಳ ಬಗ್ಗೆ ಕೆಲವು ಸರಳಗೊಳಿಸುವ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಮಾಡೋಣ, ಇವುಗಳನ್ನು ಒಟ್ಟಾಗಿ ಕರೆಯಲಾಗುತ್ತದೆ ಕೆಲಸದ ಹೊರೆ. ಕೆಲಸದ ಹೊರೆಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು ನೀತಿಗಳನ್ನು ನಿರ್ಮಿಸುವ ನಿರ್ಣಾಯಕ ಭಾಗವಾಗಿದೆ ಮತ್ತು ಕೆಲಸದ ಹೊರೆಯ ಬಗ್ಗೆ ನಿಮಗೆ ಹೆಚ್ಚು ತಿಳಿದಿರುತ್ತದೆ, ನೀವು ಬರೆಯಬಹುದಾದ ನೀತಿಯನ್ನು ಉತ್ತಮಗೊಳಿಸಬಹುದು.
ಸಿಸ್ಟಂನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಪ್ರಕ್ರಿಯೆಗಳ ಬಗ್ಗೆ ಈ ಕೆಳಗಿನ ಊಹೆಗಳನ್ನು ಮಾಡೋಣ, ಕೆಲವೊಮ್ಮೆ ಕರೆಯಲಾಗುತ್ತದೆ ಉದ್ಯೋಗಗಳು (ಕಾರ್ಯಗಳು). ಈ ಎಲ್ಲಾ ಊಹೆಗಳು ವಾಸ್ತವಿಕವಲ್ಲ, ಆದರೆ ಚಿಂತನೆಯ ಬೆಳವಣಿಗೆಗೆ ಅವಶ್ಯಕ.
- ಪ್ರತಿಯೊಂದು ಕಾರ್ಯವು ಒಂದೇ ಸಮಯದವರೆಗೆ ನಡೆಯುತ್ತದೆ,
- ಎಲ್ಲಾ ಕಾರ್ಯಗಳನ್ನು ಏಕಕಾಲದಲ್ಲಿ ಹೊಂದಿಸಲಾಗಿದೆ,
- ನಿಯೋಜಿಸಲಾದ ಕಾರ್ಯವು ಪೂರ್ಣಗೊಳ್ಳುವವರೆಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ,
- ಎಲ್ಲಾ ಕಾರ್ಯಗಳು CPU ಅನ್ನು ಮಾತ್ರ ಬಳಸುತ್ತವೆ,
- ಪ್ರತಿ ಕಾರ್ಯದ ಚಾಲನೆಯಲ್ಲಿರುವ ಸಮಯ ತಿಳಿದಿದೆ.
ಶೆಡ್ಯೂಲರ್ ಮೆಟ್ರಿಕ್ಸ್
ಲೋಡ್ ಬಗ್ಗೆ ಕೆಲವು ಊಹೆಗಳ ಜೊತೆಗೆ, ವಿಭಿನ್ನ ವೇಳಾಪಟ್ಟಿ ನೀತಿಗಳನ್ನು ಹೋಲಿಸಲು ಮತ್ತೊಂದು ಸಾಧನದ ಅಗತ್ಯವಿದೆ: ಶೆಡ್ಯೂಲರ್ ಮೆಟ್ರಿಕ್ಸ್. ಮೆಟ್ರಿಕ್ ಯಾವುದೋ ಒಂದು ಅಳತೆಯಾಗಿದೆ. ಶೆಡ್ಯೂಲರ್‌ಗಳನ್ನು ಹೋಲಿಸಲು ಹಲವಾರು ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಬಳಸಬಹುದಾಗಿದೆ.
ಉದಾಹರಣೆಗೆ, ನಾವು ಎಂಬ ಮೆಟ್ರಿಕ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ ತಿರುವು ಸಮಯ (ತಿರುವು ಸಮಯ). ಟಾಸ್ಕ್ ಟರ್ನ್ಅರೌಂಡ್ ಸಮಯವನ್ನು ಕಾರ್ಯವನ್ನು ಪೂರ್ಣಗೊಳಿಸುವ ಸಮಯ ಮತ್ತು ಸಿಸ್ಟಮ್‌ನಲ್ಲಿ ಕಾರ್ಯ ಆಗಮನದ ಸಮಯದ ನಡುವಿನ ವ್ಯತ್ಯಾಸವೆಂದು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ.
Tturnarround=Tcompletion−Tarrival
ಎಲ್ಲಾ ಕಾರ್ಯಗಳು ಒಂದೇ ಸಮಯದಲ್ಲಿ ಬಂದವು ಎಂದು ನಾವು ಊಹಿಸಿರುವುದರಿಂದ, ನಂತರ Ta=0 ಮತ್ತು ಹೀಗೆ Tt=Tc. ನಾವು ಮೇಲಿನ ಊಹೆಗಳನ್ನು ಬದಲಾಯಿಸಿದಾಗ ಈ ಮೌಲ್ಯವು ಸ್ವಾಭಾವಿಕವಾಗಿ ಬದಲಾಗುತ್ತದೆ.
ಮತ್ತೊಂದು ಮೆಟ್ರಿಕ್ - ಸೊಗಸು (ನ್ಯಾಯ, ಪ್ರಾಮಾಣಿಕತೆ). ಉತ್ಪಾದಕತೆ ಮತ್ತು ನ್ಯಾಯೋಚಿತತೆಯು ಸಾಮಾನ್ಯವಾಗಿ ಯೋಜನೆಯಲ್ಲಿ ಗುಣಲಕ್ಷಣಗಳನ್ನು ವಿರೋಧಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಶೆಡ್ಯೂಲರ್ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಉತ್ತಮಗೊಳಿಸಬಹುದು, ಆದರೆ ಇತರ ಕಾರ್ಯಗಳು ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಕಾಯುವ ವೆಚ್ಚದಲ್ಲಿ, ಹೀಗಾಗಿ ನ್ಯಾಯೋಚಿತತೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
ಫಸ್ಟ್ ಇನ್ ಫಸ್ಟ್ ಔಟ್ (FIFO)
ನಾವು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಅತ್ಯಂತ ಮೂಲಭೂತ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು FIFO ಅಥವಾ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ ಮೊದಲು ಬಂದವರು (ಒಳಗೆ), ಮೊದಲು ಸೇವೆ (ಔಟ್). ಈ ಅಲ್ಗಾರಿದಮ್ ಹಲವಾರು ಪ್ರಯೋಜನಗಳನ್ನು ಹೊಂದಿದೆ: ಇದು ಕಾರ್ಯಗತಗೊಳಿಸಲು ತುಂಬಾ ಸುಲಭ ಮತ್ತು ಇದು ನಮ್ಮ ಎಲ್ಲಾ ಊಹೆಗಳಿಗೆ ಸರಿಹೊಂದುತ್ತದೆ ಮತ್ತು ಕೆಲಸವನ್ನು ಚೆನ್ನಾಗಿ ಮಾಡುತ್ತದೆ.
ಒಂದು ಸರಳ ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ. 3 ಕಾರ್ಯಗಳನ್ನು ಏಕಕಾಲದಲ್ಲಿ ಹೊಂದಿಸಲಾಗಿದೆ ಎಂದು ಹೇಳೋಣ. ಆದರೆ A ಕಾರ್ಯವು ಎಲ್ಲಾ ಇತರರಿಗಿಂತ ಸ್ವಲ್ಪ ಮುಂಚಿತವಾಗಿ ತಲುಪಿದೆ ಎಂದು ಭಾವಿಸೋಣ, ಆದ್ದರಿಂದ ಇದು ಇತರರಿಗಿಂತ ಮುಂಚಿತವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯ ಪಟ್ಟಿಯಲ್ಲಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ, C ಗೆ ಸಂಬಂಧಿಸಿದಂತೆ B ನಂತೆ. ಅವುಗಳಲ್ಲಿ ಪ್ರತಿಯೊಂದನ್ನು 10 ಸೆಕೆಂಡುಗಳವರೆಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ ಎಂದು ಭಾವಿಸೋಣ. ಈ ಸಂದರ್ಭದಲ್ಲಿ ಈ ಕಾರ್ಯಗಳನ್ನು ಪೂರ್ಣಗೊಳಿಸಲು ಸರಾಸರಿ ಸಮಯ ಎಷ್ಟು?
ಮೌಲ್ಯಗಳನ್ನು ಎಣಿಸುವ ಮೂಲಕ - 10 + 20 + 30 ಮತ್ತು 3 ರಿಂದ ಭಾಗಿಸಿ, ನಾವು ಸರಾಸರಿ ಪ್ರೋಗ್ರಾಂ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಸಮಯವನ್ನು 20 ಸೆಕೆಂಡುಗಳಿಗೆ ಸಮಾನವಾಗಿ ಪಡೆಯುತ್ತೇವೆ.
ಈಗ ನಮ್ಮ ಊಹೆಗಳನ್ನು ಬದಲಾಯಿಸಲು ಪ್ರಯತ್ನಿಸೋಣ. ನಿರ್ದಿಷ್ಟವಾಗಿ, ಊಹೆ 1 ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ಇನ್ನು ಮುಂದೆ ಪ್ರತಿ ಕಾರ್ಯವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಒಂದೇ ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಎಂದು ಊಹಿಸುವುದಿಲ್ಲ. ಈ ಬಾರಿ FIFO ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ?
ಅದು ಬದಲಾದಂತೆ, ವಿಭಿನ್ನ ಕಾರ್ಯಗಳ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಮಯಗಳು FIFO ಅಲ್ಗಾರಿದಮ್‌ನ ಉತ್ಪಾದಕತೆಯ ಮೇಲೆ ಅತ್ಯಂತ ಋಣಾತ್ಮಕ ಪರಿಣಾಮ ಬೀರುತ್ತವೆ. ಕಾರ್ಯ A ಪೂರ್ಣಗೊಳ್ಳಲು 100 ಸೆಕೆಂಡುಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಎಂದು ಭಾವಿಸೋಣ, ಆದರೆ B ಮತ್ತು C ಇನ್ನೂ ತಲಾ 10 ಸೆಕೆಂಡುಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.
ಚಿತ್ರದಿಂದ ನೋಡಬಹುದಾದಂತೆ, ಸಿಸ್ಟಮ್‌ಗೆ ಸರಾಸರಿ ಸಮಯ (100+110+120)/3=110 ಆಗಿರುತ್ತದೆ. ಈ ಪರಿಣಾಮವನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ ಬೆಂಗಾವಲು ಪರಿಣಾಮ, ಸಂಪನ್ಮೂಲದ ಕೆಲವು ಅಲ್ಪಾವಧಿಯ ಗ್ರಾಹಕರು ಭಾರೀ ಗ್ರಾಹಕರ ನಂತರ ಸರತಿ ಸಾಲಿನಲ್ಲಿ ನಿಂತಾಗ. ತುಂಬಿದ ಗಾಡಿಯೊಂದಿಗೆ ನಿಮ್ಮ ಮುಂದೆ ಗ್ರಾಹಕರು ಇರುವಾಗ ಅದು ಕಿರಾಣಿ ಅಂಗಡಿಯಲ್ಲಿನ ಸಾಲಿನಂತೆ. ನಗದು ರಿಜಿಸ್ಟರ್ ಅನ್ನು ಬದಲಾಯಿಸಲು ಅಥವಾ ವಿಶ್ರಾಂತಿ ಮತ್ತು ಆಳವಾಗಿ ಉಸಿರಾಡಲು ಪ್ರಯತ್ನಿಸುವುದು ಸಮಸ್ಯೆಗೆ ಉತ್ತಮ ಪರಿಹಾರವಾಗಿದೆ.
ಚಿಕ್ಕದಾದ ಕೆಲಸ ಮೊದಲು
ಹೆವಿವೇಯ್ಟ್ ಪ್ರಕ್ರಿಯೆಗಳೊಂದಿಗೆ ಇದೇ ರೀತಿಯ ಪರಿಸ್ಥಿತಿಯನ್ನು ಹೇಗಾದರೂ ಪರಿಹರಿಸಲು ಸಾಧ್ಯವೇ? ಖಂಡಿತವಾಗಿಯೂ. ಮತ್ತೊಂದು ರೀತಿಯ ಯೋಜನೆಯನ್ನು ಕರೆಯಲಾಗುತ್ತದೆಚಿಕ್ಕದಾದ ಕೆಲಸ ಮೊದಲು (SJF). ಇದರ ಅಲ್ಗಾರಿದಮ್ ಸಹ ಸಾಕಷ್ಟು ಪ್ರಾಚೀನವಾಗಿದೆ - ಹೆಸರೇ ಸೂಚಿಸುವಂತೆ, ಚಿಕ್ಕದಾದ ಕಾರ್ಯಗಳನ್ನು ಒಂದರ ನಂತರ ಒಂದರಂತೆ ಮೊದಲು ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ.
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ಅದೇ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ನಡೆಸುವ ಫಲಿತಾಂಶವು ಸರಾಸರಿ ಪ್ರೋಗ್ರಾಂ ಟರ್ನ್ಅರೌಂಡ್ ಸಮಯದಲ್ಲಿ ಸುಧಾರಣೆಯಾಗಿರುತ್ತದೆ ಮತ್ತು ಅದು ಸಮಾನವಾಗಿರುತ್ತದೆ 50 ರ ಬದಲಿಗೆ 110, ಇದು ಸುಮಾರು 2 ಪಟ್ಟು ಉತ್ತಮವಾಗಿದೆ.
ಹೀಗಾಗಿ, ಎಲ್ಲಾ ಕಾರ್ಯಗಳು ಒಂದೇ ಸಮಯದಲ್ಲಿ ಬರುತ್ತವೆ ಎಂದು ನೀಡಿದ ಊಹೆಗೆ, SJF ಅಲ್ಗಾರಿದಮ್ ಅತ್ಯಂತ ಸೂಕ್ತವಾದ ಅಲ್ಗಾರಿದಮ್ ಎಂದು ತೋರುತ್ತದೆ. ಆದಾಗ್ಯೂ, ನಮ್ಮ ಊಹೆಗಳು ಇನ್ನೂ ವಾಸ್ತವಿಕವಾಗಿ ಕಾಣುತ್ತಿಲ್ಲ. ಈ ಸಮಯದಲ್ಲಿ ನಾವು ಊಹೆ 2 ಅನ್ನು ಬದಲಾಯಿಸುತ್ತೇವೆ ಮತ್ತು ಈ ಸಮಯದಲ್ಲಿ ಕಾರ್ಯಗಳು ಯಾವುದೇ ಸಮಯದಲ್ಲಿ ಇರಬಹುದೆಂದು ಊಹಿಸಿ, ಮತ್ತು ಎಲ್ಲಾ ಒಂದೇ ಸಮಯದಲ್ಲಿ ಅಲ್ಲ. ಇದು ಯಾವ ಸಮಸ್ಯೆಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು?
ಕಾರ್ಯ A (100c) ಮೊದಲು ಬರುತ್ತದೆ ಮತ್ತು ಕಾರ್ಯಗತಗೊಳ್ಳಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ ಎಂದು ಊಹಿಸೋಣ. t=10 ನಲ್ಲಿ, ಕಾರ್ಯಗಳು B ಮತ್ತು C ಆಗಮಿಸುತ್ತವೆ, ಪ್ರತಿಯೊಂದೂ 10 ಸೆಕೆಂಡುಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಆದ್ದರಿಂದ ಸರಾಸರಿ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಸಮಯ (100+(110-10)+(120-10))3 = 103. ಇದನ್ನು ಸುಧಾರಿಸಲು ಶೆಡ್ಯೂಲರ್ ಏನು ಮಾಡಬಹುದು?
ಮೊದಲು ಪೂರ್ಣಗೊಳಿಸಲು ಕಡಿಮೆ ಸಮಯ (STCF)
ಪರಿಸ್ಥಿತಿಯನ್ನು ಸುಧಾರಿಸುವ ಸಲುವಾಗಿ, ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ ಮತ್ತು ಪೂರ್ಣಗೊಳ್ಳುವವರೆಗೆ ರನ್ ಆಗುತ್ತದೆ ಎಂಬ ಊಹೆ 3 ಅನ್ನು ನಾವು ಬಿಟ್ಟುಬಿಡುತ್ತೇವೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ನಮಗೆ ಹಾರ್ಡ್‌ವೇರ್ ಬೆಂಬಲ ಬೇಕಾಗುತ್ತದೆ ಮತ್ತು, ನೀವು ಊಹಿಸುವಂತೆ, ನಾವು ಬಳಸುತ್ತೇವೆ ಟೈಮರ್ ಚಾಲನೆಯಲ್ಲಿರುವ ಕಾರ್ಯವನ್ನು ಅಡ್ಡಿಪಡಿಸಲು ಮತ್ತು ಸಂದರ್ಭ ಸ್ವಿಚಿಂಗ್. ಹೀಗಾಗಿ, ಕಾರ್ಯಗಳು ಬಿ, ಸಿ ಬಂದ ಕ್ಷಣದಲ್ಲಿ ಶೆಡ್ಯೂಲರ್ ಏನನ್ನಾದರೂ ಮಾಡಬಹುದು - ಟಾಸ್ಕ್ ಎ ಎಕ್ಸಿಕ್ಯೂಟ್ ಮಾಡುವುದನ್ನು ನಿಲ್ಲಿಸಿ ಮತ್ತು ಬಿ ಮತ್ತು ಸಿ ಕಾರ್ಯಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೆ ಇರಿಸಿ ಮತ್ತು ಅವು ಪೂರ್ಣಗೊಂಡ ನಂತರ, ಎಕ್ಸಿಕ್ಯೂಟ್ ಮಾಡುವುದನ್ನು ಮುಂದುವರಿಸಿ. ಅಂತಹ ಶೆಡ್ಯೂಲರ್ ಅನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ STCFಅಥವಾ ಪೂರ್ವಭಾವಿ ಕೆಲಸ ಮೊದಲು.
ಈ ಯೋಜಕರ ಫಲಿತಾಂಶವು ಈ ಕೆಳಗಿನ ಫಲಿತಾಂಶವಾಗಿರುತ್ತದೆ: ((120-0)+(20-10)+(30-10))/3=50. ಹೀಗಾಗಿ, ಅಂತಹ ಶೆಡ್ಯೂಲರ್ ನಮ್ಮ ಕಾರ್ಯಗಳಿಗೆ ಇನ್ನಷ್ಟು ಸೂಕ್ತವಾಗಿದೆ.
ಮೆಟ್ರಿಕ್ ಪ್ರತಿಕ್ರಿಯೆ ಸಮಯ
ಹೀಗಾಗಿ, ಕಾರ್ಯಗಳ ಚಾಲನೆಯಲ್ಲಿರುವ ಸಮಯವನ್ನು ನಾವು ತಿಳಿದಿದ್ದರೆ ಮತ್ತು ಈ ಕಾರ್ಯಗಳು CPU ಅನ್ನು ಮಾತ್ರ ಬಳಸಿದರೆ, STCF ಉತ್ತಮ ಪರಿಹಾರವಾಗಿದೆ. ಮತ್ತು ಒಮ್ಮೆ ಆರಂಭಿಕ ಕಾಲದಲ್ಲಿ, ಈ ಅಲ್ಗಾರಿದಮ್‌ಗಳು ಚೆನ್ನಾಗಿ ಕೆಲಸ ಮಾಡುತ್ತವೆ. ಆದಾಗ್ಯೂ, ಬಳಕೆದಾರರು ಈಗ ತನ್ನ ಹೆಚ್ಚಿನ ಸಮಯವನ್ನು ಟರ್ಮಿನಲ್‌ನಲ್ಲಿ ಕಳೆಯುತ್ತಾರೆ ಮತ್ತು ಉತ್ಪಾದಕ ಸಂವಾದಾತ್ಮಕ ಅನುಭವವನ್ನು ನಿರೀಕ್ಷಿಸುತ್ತಾರೆ. ಹೀಗೆ ಹೊಸ ಮೆಟ್ರಿಕ್ ಹುಟ್ಟಿತು - ಪ್ರತಿಕ್ರಿಯೆ ಸಮಯ (ಪ್ರತಿಕ್ರಿಯೆ).
ಪ್ರತಿಕ್ರಿಯೆ ಸಮಯವನ್ನು ಈ ಕೆಳಗಿನಂತೆ ಲೆಕ್ಕಹಾಕಲಾಗುತ್ತದೆ:
Tresponse=Tfirstrun−Tarrival
ಹೀಗಾಗಿ, ಹಿಂದಿನ ಉದಾಹರಣೆಗಾಗಿ, ಪ್ರತಿಕ್ರಿಯೆ ಸಮಯ ಹೀಗಿರುತ್ತದೆ: A=0, B=0, C=10 (abg=3,33).
ಮತ್ತು 3 ಕಾರ್ಯಗಳು ಒಂದೇ ಸಮಯದಲ್ಲಿ ಬರುವ ಪರಿಸ್ಥಿತಿಯಲ್ಲಿ STCF ಅಲ್ಗಾರಿದಮ್ ಅಷ್ಟು ಉತ್ತಮವಾಗಿಲ್ಲ ಎಂದು ಅದು ತಿರುಗುತ್ತದೆ - ಸಣ್ಣ ಕಾರ್ಯಗಳು ಸಂಪೂರ್ಣವಾಗಿ ಪೂರ್ಣಗೊಳ್ಳುವವರೆಗೆ ಇದು ಕಾಯಬೇಕಾಗುತ್ತದೆ. ಆದ್ದರಿಂದ ಅಲ್ಗಾರಿದಮ್ ಟರ್ನ್ಅರೌಂಡ್ ಟೈಮ್ ಮೆಟ್ರಿಕ್‌ಗೆ ಉತ್ತಮವಾಗಿದೆ, ಆದರೆ ಇಂಟರಾಕ್ಟಿವಿಟಿ ಮೆಟ್ರಿಕ್‌ಗೆ ಕೆಟ್ಟದಾಗಿದೆ. ನೀವು ಟರ್ಮಿನಲ್‌ನಲ್ಲಿ ಎಡಿಟರ್‌ನಲ್ಲಿ ಅಕ್ಷರಗಳನ್ನು ಟೈಪ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೆ ಮತ್ತು 10 ಸೆಕೆಂಡ್‌ಗಳಿಗಿಂತ ಹೆಚ್ಚು ಕಾಯಬೇಕಾಗಿದ್ದರೆ, ಬೇರೆ ಕೆಲವು ಕಾರ್ಯಗಳು CPU ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತಿದ್ದರೆ ಊಹಿಸಿ. ಇದು ತುಂಬಾ ಆಹ್ಲಾದಕರವಲ್ಲ.
ಆದ್ದರಿಂದ ನಾವು ಮತ್ತೊಂದು ಸಮಸ್ಯೆಯನ್ನು ಎದುರಿಸುತ್ತಿದ್ದೇವೆ - ಪ್ರತಿಕ್ರಿಯೆ ಸಮಯಕ್ಕೆ ಸೂಕ್ಷ್ಮವಾಗಿರುವ ಶೆಡ್ಯೂಲರ್ ಅನ್ನು ನಾವು ಹೇಗೆ ನಿರ್ಮಿಸಬಹುದು?
ರೌಂಡ್ ರಾಬಿನ್
ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲಾಗಿದೆ ರೌಂಡ್ ರಾಬಿನ್ (RR). ಮೂಲಭೂತ ಕಲ್ಪನೆಯು ತುಂಬಾ ಸರಳವಾಗಿದೆ: ಕಾರ್ಯಗಳನ್ನು ಪೂರ್ಣಗೊಳಿಸುವವರೆಗೆ ಚಾಲನೆ ಮಾಡುವ ಬದಲು, ನಾವು ನಿರ್ದಿಷ್ಟ ಸಮಯದವರೆಗೆ ಕಾರ್ಯವನ್ನು ರನ್ ಮಾಡುತ್ತೇವೆ (ಟೈಮ್ ಸ್ಲೈಸ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ) ಮತ್ತು ನಂತರ ಸರದಿಯಿಂದ ಮತ್ತೊಂದು ಕಾರ್ಯಕ್ಕೆ ಬದಲಾಯಿಸುತ್ತೇವೆ. ಎಲ್ಲಾ ಕಾರ್ಯಗಳು ಪೂರ್ಣಗೊಳ್ಳುವವರೆಗೆ ಅಲ್ಗಾರಿದಮ್ ತನ್ನ ಕೆಲಸವನ್ನು ಪುನರಾವರ್ತಿಸುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಪ್ರೋಗ್ರಾಂನ ಚಾಲನೆಯಲ್ಲಿರುವ ಸಮಯವು ಟೈಮರ್ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಅಡ್ಡಿಪಡಿಸುವ ಸಮಯದ ಬಹುಸಂಖ್ಯೆಯಾಗಿರಬೇಕು. ಉದಾಹರಣೆಗೆ, ಒಂದು ಟೈಮರ್ ಪ್ರತಿ x=10ms ಒಂದು ಪ್ರಕ್ರಿಯೆಯನ್ನು ಅಡ್ಡಿಪಡಿಸಿದರೆ, ನಂತರ ಪ್ರಕ್ರಿಯೆಯ ಎಕ್ಸಿಕ್ಯೂಶನ್ ವಿಂಡೋದ ಗಾತ್ರವು 10 ರ ಬಹುಸಂಖ್ಯೆಯಾಗಿರಬೇಕು ಮತ್ತು 10,20 ಅಥವಾ x*10 ಆಗಿರಬೇಕು.
ಒಂದು ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ: ಎಬಿಸಿ ಕಾರ್ಯಗಳು ಏಕಕಾಲದಲ್ಲಿ ಸಿಸ್ಟಮ್‌ನಲ್ಲಿ ಬರುತ್ತವೆ ಮತ್ತು ಅವುಗಳಲ್ಲಿ ಪ್ರತಿಯೊಂದೂ 5 ಸೆಕೆಂಡುಗಳ ಕಾಲ ಚಲಾಯಿಸಲು ಬಯಸುತ್ತವೆ. SJF ಅಲ್ಗಾರಿದಮ್ ಪ್ರತಿ ಕೆಲಸವನ್ನು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು ಪೂರ್ಣಗೊಳಿಸುತ್ತದೆ. ಇದಕ್ಕೆ ವ್ಯತಿರಿಕ್ತವಾಗಿ, ಲಾಂಚ್ ವಿಂಡೋ = 1s ಜೊತೆಗೆ RR ಅಲ್ಗಾರಿದಮ್ ಈ ಕೆಳಗಿನಂತೆ ಕಾರ್ಯಗಳ ಮೂಲಕ ಹೋಗುತ್ತದೆ (Fig. 4.3):
(SJF ಮತ್ತೆ (ಪ್ರತಿಕ್ರಿಯೆ ಸಮಯಕ್ಕೆ ಕೆಟ್ಟದು)
(ರೌಂಡ್ ರಾಬಿನ್ (ಪ್ರತಿಕ್ರಿಯೆ ಸಮಯಕ್ಕೆ ಉತ್ತಮ)
RR ಅಲ್ಗಾರಿದಮ್‌ಗೆ ಸರಾಸರಿ ಪ್ರತಿಕ್ರಿಯೆ ಸಮಯ (0+1+2)/3=1, ಆದರೆ SJF (0+5+10)/3=5.
ಸಮಯ ವಿಂಡೋ RR ಗೆ ಬಹಳ ಮುಖ್ಯವಾದ ನಿಯತಾಂಕವಾಗಿದೆ ಎಂದು ಊಹಿಸುವುದು ತಾರ್ಕಿಕವಾಗಿದೆ; ಅದು ಚಿಕ್ಕದಾಗಿದೆ, ಹೆಚ್ಚಿನ ಪ್ರತಿಕ್ರಿಯೆ ಸಮಯ. ಆದಾಗ್ಯೂ, ನೀವು ಅದನ್ನು ತುಂಬಾ ಚಿಕ್ಕದಾಗಿ ಮಾಡಬಾರದು, ಏಕೆಂದರೆ ಸಂದರ್ಭ ಸ್ವಿಚಿಂಗ್ ಸಮಯವು ಒಟ್ಟಾರೆ ಕಾರ್ಯಕ್ಷಮತೆಯಲ್ಲಿ ಪಾತ್ರವನ್ನು ವಹಿಸುತ್ತದೆ. ಹೀಗಾಗಿ, ಎಕ್ಸಿಕ್ಯೂಶನ್ ವಿಂಡೋ ಸಮಯದ ಆಯ್ಕೆಯನ್ನು ಓಎಸ್ ಆರ್ಕಿಟೆಕ್ಟ್ ಹೊಂದಿಸುತ್ತದೆ ಮತ್ತು ಅದರಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಯೋಜಿಸಲಾದ ಕಾರ್ಯಗಳನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ಸಂದರ್ಭವನ್ನು ಬದಲಾಯಿಸುವುದು ಸಮಯವನ್ನು ವ್ಯರ್ಥ ಮಾಡುವ ಏಕೈಕ ಸೇವಾ ಕಾರ್ಯಾಚರಣೆಯಲ್ಲ - ಚಾಲನೆಯಲ್ಲಿರುವ ಪ್ರೋಗ್ರಾಂ ಹಲವಾರು ಇತರ ವಿಷಯಗಳ ಮೇಲೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಉದಾಹರಣೆಗೆ, ವಿವಿಧ ಕ್ಯಾಶ್‌ಗಳು, ಮತ್ತು ಪ್ರತಿ ಸ್ವಿಚ್‌ನೊಂದಿಗೆ ಈ ಪರಿಸರವನ್ನು ಉಳಿಸಲು ಮತ್ತು ಪುನಃಸ್ಥಾಪಿಸಲು ಇದು ಅಗತ್ಯವಾಗಿರುತ್ತದೆ, ಇದು ಸಾಕಷ್ಟು ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಸಮಯ.
ನಾವು ಪ್ರತಿಕ್ರಿಯೆ ಸಮಯದ ಮೆಟ್ರಿಕ್ ಬಗ್ಗೆ ಮಾತ್ರ ಮಾತನಾಡುತ್ತಿದ್ದರೆ RR ಉತ್ತಮ ಶೆಡ್ಯೂಲರ್ ಆಗಿದೆ. ಆದರೆ ಈ ಅಲ್ಗಾರಿದಮ್‌ನೊಂದಿಗೆ ಟಾಸ್ಕ್ ಟರ್ನ್ಅರೌಂಡ್ ಟೈಮ್ ಮೆಟ್ರಿಕ್ ಹೇಗೆ ವರ್ತಿಸುತ್ತದೆ? ಮೇಲಿನ ಉದಾಹರಣೆಯನ್ನು ಪರಿಗಣಿಸಿ, A, B, C = 5s ನ ಕಾರ್ಯಾಚರಣೆಯ ಸಮಯ ಮತ್ತು ಅದೇ ಸಮಯದಲ್ಲಿ ಬಂದಾಗ. ಟಾಸ್ಕ್ A 13 ಕ್ಕೆ, B 14 ಕ್ಕೆ, C 15 ಕ್ಕೆ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಸರಾಸರಿ ಟರ್ನ್ಅರೌಂಡ್ ಸಮಯ 14 ಸೆ. ಹೀಗಾಗಿ, ವಹಿವಾಟು ಮೆಟ್ರಿಕ್‌ಗೆ RR ಕೆಟ್ಟ ಅಲ್ಗಾರಿದಮ್ ಆಗಿದೆ.
ಹೆಚ್ಚು ಸಾಮಾನ್ಯ ಪರಿಭಾಷೆಯಲ್ಲಿ, ಯಾವುದೇ RR-ಮಾದರಿಯ ಅಲ್ಗಾರಿದಮ್ ನ್ಯಾಯೋಚಿತವಾಗಿದೆ; ಇದು CPU ಸಮಯವನ್ನು ಎಲ್ಲಾ ಪ್ರಕ್ರಿಯೆಗಳ ನಡುವೆ ಸಮಾನವಾಗಿ ವಿಭಜಿಸುತ್ತದೆ. ಹೀಗಾಗಿ, ಈ ಮೆಟ್ರಿಕ್‌ಗಳು ನಿರಂತರವಾಗಿ ಪರಸ್ಪರ ಸಂಘರ್ಷಿಸುತ್ತವೆ.
ಹೀಗಾಗಿ, ನಾವು ಹಲವಾರು ವ್ಯತಿರಿಕ್ತ ಅಲ್ಗಾರಿದಮ್‌ಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ ಮತ್ತು ಅದೇ ಸಮಯದಲ್ಲಿ ಇನ್ನೂ ಹಲವಾರು ಊಹೆಗಳು ಉಳಿದಿವೆ - ಕಾರ್ಯದ ಸಮಯವನ್ನು ತಿಳಿದಿದೆ ಮತ್ತು ಕಾರ್ಯವು CPU ಅನ್ನು ಮಾತ್ರ ಬಳಸುತ್ತದೆ.
I/O ನೊಂದಿಗೆ ಮಿಶ್ರಣ
ಮೊದಲನೆಯದಾಗಿ, ಪ್ರಕ್ರಿಯೆಯು CPU ಅನ್ನು ಮಾತ್ರ ಬಳಸುತ್ತದೆ ಎಂಬ ಊಹೆ 4 ಅನ್ನು ತೆಗೆದುಹಾಕೋಣ; ಸ್ವಾಭಾವಿಕವಾಗಿ, ಇದು ಹಾಗಲ್ಲ ಮತ್ತು ಪ್ರಕ್ರಿಯೆಗಳು ಇತರ ಸಾಧನಗಳನ್ನು ಪ್ರವೇಶಿಸಬಹುದು.
ಯಾವುದೇ ಪ್ರಕ್ರಿಯೆಯು I/O ಕಾರ್ಯಾಚರಣೆಯನ್ನು ವಿನಂತಿಸಿದಾಗ, ಪ್ರಕ್ರಿಯೆಯು ನಿರ್ಬಂಧಿಸಲಾದ ಸ್ಥಿತಿಯನ್ನು ಪ್ರವೇಶಿಸುತ್ತದೆ, I/O ಪೂರ್ಣಗೊಳ್ಳಲು ಕಾಯುತ್ತಿದೆ. I/O ಅನ್ನು ಹಾರ್ಡ್ ಡ್ರೈವ್‌ಗೆ ಕಳುಹಿಸಿದರೆ, ಅಂತಹ ಕಾರ್ಯಾಚರಣೆಯು ಹಲವಾರು ms ಅಥವಾ ಹೆಚ್ಚಿನ ಸಮಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಮತ್ತು ಈ ಕ್ಷಣದಲ್ಲಿ ಪ್ರೊಸೆಸರ್ ನಿಷ್ಕ್ರಿಯವಾಗಿರುತ್ತದೆ. ಈ ಸಮಯದಲ್ಲಿ, ಶೆಡ್ಯೂಲರ್ ಯಾವುದೇ ಇತರ ಪ್ರಕ್ರಿಯೆಯೊಂದಿಗೆ ಪ್ರೊಸೆಸರ್ ಅನ್ನು ಆಕ್ರಮಿಸಿಕೊಳ್ಳಬಹುದು. ಪ್ರಕ್ರಿಯೆಯು ಅದರ I/O ಅನ್ನು ಯಾವಾಗ ಪೂರ್ಣಗೊಳಿಸುತ್ತದೆ ಎಂಬುದು ಶೆಡ್ಯೂಲರ್ ತೆಗೆದುಕೊಳ್ಳಬೇಕಾದ ಮುಂದಿನ ನಿರ್ಧಾರ. ಇದು ಸಂಭವಿಸಿದಾಗ, ಒಂದು ಅಡಚಣೆ ಉಂಟಾಗುತ್ತದೆ ಮತ್ತು OS I/O ಎಂದು ಕರೆಯುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸಿದ್ಧ ಸ್ಥಿತಿಗೆ ಹಾಕುತ್ತದೆ.
ಹಲವಾರು ಕಾರ್ಯಗಳ ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ. ಅವುಗಳಲ್ಲಿ ಪ್ರತಿಯೊಂದಕ್ಕೂ 50ms CPU ಸಮಯದ ಅಗತ್ಯವಿದೆ. ಆದಾಗ್ಯೂ, ಮೊದಲನೆಯದು I/O ಅನ್ನು ಪ್ರತಿ 10ms ಗೆ ಪ್ರವೇಶಿಸುತ್ತದೆ (ಇದು ಪ್ರತಿ 10ms ಗೆ ಸಹ ಕಾರ್ಯಗತಗೊಳ್ಳುತ್ತದೆ). ಮತ್ತು ಪ್ರಕ್ರಿಯೆ B ಕೇವಲ I/O ಇಲ್ಲದೆ 50ms ಪ್ರೊಸೆಸರ್ ಅನ್ನು ಬಳಸುತ್ತದೆ.
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ ನಾವು STCF ಶೆಡ್ಯೂಲರ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ. A ಯಂತಹ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪ್ರಾರಂಭಿಸಿದರೆ ಶೆಡ್ಯೂಲರ್ ಹೇಗೆ ವರ್ತಿಸುತ್ತಾನೆ? ಅವನು ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಮಾಡುತ್ತಾನೆ: ಮೊದಲು ಅವನು ಎ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಕೆಲಸ ಮಾಡುತ್ತಾನೆ ಮತ್ತು ನಂತರ ಬಿ ಅನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತಾನೆ.
ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಸಾಂಪ್ರದಾಯಿಕ ವಿಧಾನವೆಂದರೆ ಪ್ರಕ್ರಿಯೆ A ಯ ಪ್ರತಿ 10 ms ಉಪಕಾರ್ಯವನ್ನು ಪ್ರತ್ಯೇಕ ಕಾರ್ಯವಾಗಿ ಪರಿಗಣಿಸುವುದು. ಹೀಗಾಗಿ, STJF ಅಲ್ಗಾರಿದಮ್‌ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸುವಾಗ, 50 ms ಕಾರ್ಯ ಮತ್ತು 10 ms ಕಾರ್ಯಗಳ ನಡುವಿನ ಆಯ್ಕೆಯು ಸ್ಪಷ್ಟವಾಗಿರುತ್ತದೆ. ನಂತರ, ಉಪಕಾರ್ಯ A ಪೂರ್ಣಗೊಂಡಾಗ, ಪ್ರಕ್ರಿಯೆ B ಮತ್ತು I/O ಅನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ. I/O ಪೂರ್ಣಗೊಂಡ ನಂತರ, ಪ್ರಕ್ರಿಯೆ B ಬದಲಿಗೆ 10ms ಪ್ರಕ್ರಿಯೆ A ಅನ್ನು ಮತ್ತೆ ಪ್ರಾರಂಭಿಸುವುದು ವಾಡಿಕೆಯಾಗಿದೆ. ಈ ರೀತಿಯಲ್ಲಿ, ಅತಿಕ್ರಮಣವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಸಾಧ್ಯವಿದೆ, ಅಲ್ಲಿ CPU ಅನ್ನು ಮತ್ತೊಂದು ಪ್ರಕ್ರಿಯೆಯಿಂದ ಬಳಸಲಾಗುವುದು, ಮೊದಲನೆಯದು ಕಾಯುತ್ತಿರುವಾಗ I/O. ಮತ್ತು ಪರಿಣಾಮವಾಗಿ, ಸಿಸ್ಟಮ್ ಅನ್ನು ಉತ್ತಮವಾಗಿ ಬಳಸಿಕೊಳ್ಳಲಾಗುತ್ತದೆ - ಸಂವಾದಾತ್ಮಕ ಪ್ರಕ್ರಿಯೆಗಳು I / O ಗಾಗಿ ಕಾಯುತ್ತಿರುವ ಕ್ಷಣದಲ್ಲಿ, ಪ್ರೊಸೆಸರ್ನಲ್ಲಿ ಇತರ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು.
ಒರಾಕಲ್ ಈಗಿಲ್ಲ
ಈಗ ಕಾರ್ಯದ ಚಾಲನೆಯಲ್ಲಿರುವ ಸಮಯ ತಿಳಿದಿದೆ ಎಂಬ ಊಹೆಯನ್ನು ತೊಡೆದುಹಾಕಲು ಪ್ರಯತ್ನಿಸೋಣ. ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಇಡೀ ಪಟ್ಟಿಯಲ್ಲಿ ಅತ್ಯಂತ ಕೆಟ್ಟ ಮತ್ತು ಅವಾಸ್ತವಿಕ ಊಹೆಯಾಗಿದೆ. ವಾಸ್ತವವಾಗಿ, ಸರಾಸರಿ ಸಾಮಾನ್ಯ ಓಎಸ್‌ನಲ್ಲಿ, ಕಾರ್ಯಗಳ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಮಯದ ಬಗ್ಗೆ ಓಎಸ್‌ಗೆ ಸಾಮಾನ್ಯವಾಗಿ ಬಹಳ ಕಡಿಮೆ ತಿಳಿದಿದೆ, ಆದ್ದರಿಂದ ಕಾರ್ಯವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಎಷ್ಟು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಎಂದು ತಿಳಿಯದೆ ನೀವು ಶೆಡ್ಯೂಲರ್ ಅನ್ನು ಹೇಗೆ ನಿರ್ಮಿಸಬಹುದು? ಬಹುಶಃ ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ನಾವು ಕೆಲವು RR ತತ್ವಗಳನ್ನು ಬಳಸಬಹುದೇ?
ಫಲಿತಾಂಶ
ನಾವು ಕಾರ್ಯ ವೇಳಾಪಟ್ಟಿಯ ಮೂಲ ವಿಚಾರಗಳನ್ನು ನೋಡಿದ್ದೇವೆ ಮತ್ತು 2 ಶೆಡ್ಯೂಲರ್‌ಗಳ ಕುಟುಂಬಗಳನ್ನು ನೋಡಿದ್ದೇವೆ. ಮೊದಲನೆಯದು ಚಿಕ್ಕದಾದ ಕೆಲಸವನ್ನು ಮೊದಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ ಮತ್ತು ಹೀಗಾಗಿ ತಿರುಗುವ ಸಮಯವನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ, ಆದರೆ ಎರಡನೆಯದು ಎಲ್ಲಾ ಕಾರ್ಯಗಳ ನಡುವೆ ಸಮಾನವಾಗಿ ಹರಿದುಹೋಗುತ್ತದೆ, ಪ್ರತಿಕ್ರಿಯೆ ಸಮಯವನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ. ಇತರ ಕುಟುಂಬದ ಅಲ್ಗಾರಿದಮ್‌ಗಳು ಉತ್ತಮವಾಗಿರುವಲ್ಲಿ ಎರಡೂ ಅಲ್ಗಾರಿದಮ್‌ಗಳು ಕೆಟ್ಟದಾಗಿವೆ. CPU ಮತ್ತು I/O ಯ ಸಮಾನಾಂತರ ಬಳಕೆಯು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಹೇಗೆ ಸುಧಾರಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನಾವು ನೋಡಿದ್ದೇವೆ, ಆದರೆ OS ಕ್ಲೈರ್ವಾಯನ್ಸ್‌ನೊಂದಿಗೆ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲಿಲ್ಲ. ಮತ್ತು ಮುಂದಿನ ಪಾಠದಲ್ಲಿ ನಾವು ತಕ್ಷಣದ ಭೂತಕಾಲವನ್ನು ನೋಡುವ ಮತ್ತು ಭವಿಷ್ಯವನ್ನು ಊಹಿಸಲು ಪ್ರಯತ್ನಿಸುವ ಯೋಜಕನನ್ನು ನೋಡುತ್ತೇವೆ. ಮತ್ತು ಇದನ್ನು ಬಹು-ಹಂತದ ಪ್ರತಿಕ್ರಿಯೆ ಕ್ಯೂ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.
ಮೂಲ: www.habr.com