ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂಗಳ ಪರಿಚಯ

ಹೇ ಹಬ್ರ್! ನನ್ನ ಅಭಿಪ್ರಾಯದಲ್ಲಿ ಒಂದು ಆಸಕ್ತಿದಾಯಕ ಸಾಹಿತ್ಯದ ಲೇಖನಗಳು-ಅನುವಾದಗಳ ಸರಣಿಯನ್ನು ನಿಮ್ಮ ಗಮನಕ್ಕೆ ತರಲು ನಾನು ಬಯಸುತ್ತೇನೆ - OSTEP. ಈ ವಸ್ತುವು ಯುನಿಕ್ಸ್ ತರಹದ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂಗಳ ಕೆಲಸವನ್ನು ಸಾಕಷ್ಟು ಆಳವಾಗಿ ಚರ್ಚಿಸುತ್ತದೆ, ಅವುಗಳೆಂದರೆ, ಪ್ರಕ್ರಿಯೆಗಳು, ವಿವಿಧ ಶೆಡ್ಯೂಲರ್‌ಗಳು, ಮೆಮೊರಿ ಮತ್ತು ಆಧುನಿಕ OS ಅನ್ನು ರೂಪಿಸುವ ಇತರ ರೀತಿಯ ಘಟಕಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ. ಎಲ್ಲಾ ವಸ್ತುಗಳ ಮೂಲವನ್ನು ನೀವು ಇಲ್ಲಿ ನೋಡಬಹುದು ಇಲ್ಲಿ. ಅನುವಾದವನ್ನು ವೃತ್ತಿಪರವಲ್ಲದ (ಸಾಕಷ್ಟು ಮುಕ್ತವಾಗಿ) ಮಾಡಲಾಗಿದೆ ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ, ಆದರೆ ನಾನು ಸಾಮಾನ್ಯ ಅರ್ಥವನ್ನು ಉಳಿಸಿಕೊಂಡಿದ್ದೇನೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ.

ಈ ವಿಷಯದ ಕುರಿತು ಲ್ಯಾಬ್ ಕೆಲಸವನ್ನು ಇಲ್ಲಿ ಕಾಣಬಹುದು:

• ಮೂಲ: pages.cs.wisc.edu/~remzi/OSTEP/Homework/homework.html
• ಮೂಲ: github.com/remzi-arpacidusseau/ostep-code
• ನನ್ನ ವೈಯಕ್ತಿಕ ರೂಪಾಂತರ: github.com/bykvaadm/OS/tree/master/ostep

ಇತರ ಭಾಗಗಳು:

• ಭಾಗ 1: ಪರಿಚಯ

ನೀವು ನನ್ನ ಚಾನಲ್ ಅನ್ನು ಸಹ ಇಲ್ಲಿ ಪರಿಶೀಲಿಸಬಹುದು ಟೆಲಿಗ್ರಾಮ್ =)

ಓಎಸ್ ಬಳಕೆದಾರರಿಗೆ ಒದಗಿಸುವ ಅತ್ಯಂತ ಮೂಲಭೂತ ಅಮೂರ್ತತೆಯನ್ನು ನೋಡೋಣ: ಪ್ರಕ್ರಿಯೆ. ಪ್ರಕ್ರಿಯೆಯ ವ್ಯಾಖ್ಯಾನವು ತುಂಬಾ ಸರಳವಾಗಿದೆ - ಅದು ಚಾಲನೆಯಲ್ಲಿರುವ ಪ್ರೋಗ್ರಾಂ. ಪ್ರೋಗ್ರಾಂ ಸ್ವತಃ ಡಿಸ್ಕ್ನಲ್ಲಿರುವ ನಿರ್ಜೀವ ವಸ್ತುವಾಗಿದೆ - ಇದು ಸೂಚನೆಗಳ ಒಂದು ಸೆಟ್ ಮತ್ತು ಪ್ರಾಯಶಃ ಕೆಲವು ಸ್ಥಿರ ಡೇಟಾ ಪ್ರಾರಂಭಿಸಲು ಕಾಯುತ್ತಿದೆ. ಇದು OS ಆ ಬೈಟ್‌ಗಳನ್ನು ತೆಗೆದುಕೊಂಡು ಅವುಗಳನ್ನು ರನ್ ಮಾಡುತ್ತದೆ, ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಉಪಯುಕ್ತವಾಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ.
ಹೆಚ್ಚಾಗಿ, ಬಳಕೆದಾರರು ಒಂದೇ ಸಮಯದಲ್ಲಿ ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ಚಲಾಯಿಸಲು ಬಯಸುತ್ತಾರೆ, ಉದಾಹರಣೆಗೆ, ನಿಮ್ಮ ಲ್ಯಾಪ್ಟಾಪ್ನಲ್ಲಿ ನೀವು ಬ್ರೌಸರ್, ಆಟ, ಮೀಡಿಯಾ ಪ್ಲೇಯರ್, ಪಠ್ಯ ಸಂಪಾದಕ ಮತ್ತು ಮುಂತಾದವುಗಳನ್ನು ಚಲಾಯಿಸಬಹುದು. ವಾಸ್ತವವಾಗಿ, ಒಂದು ವಿಶಿಷ್ಟವಾದ ವ್ಯವಸ್ಥೆಯು ಹತ್ತಾರು ಅಥವಾ ನೂರಾರು ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಏಕಕಾಲದಲ್ಲಿ ನಡೆಸಬಹುದು. ಈ ಅಂಶವು ಸಿಸ್ಟಮ್ ಅನ್ನು ಬಳಸಲು ಸುಲಭಗೊಳಿಸುತ್ತದೆ, CPU ಉಚಿತವಾಗಿದೆಯೇ ಎಂದು ನೀವು ಎಂದಿಗೂ ಚಿಂತಿಸಬೇಕಾಗಿಲ್ಲ, ನೀವು ಕೇವಲ ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ರನ್ ಮಾಡಿ.

ಇದು ಸಮಸ್ಯೆಯನ್ನು ಹುಟ್ಟುಹಾಕುತ್ತದೆ: ಅನೇಕ CPUಗಳ ಭ್ರಮೆಯನ್ನು ಹೇಗೆ ಒದಗಿಸುವುದು? ನೀವು ಕೇವಲ ಒಂದು ಭೌತಿಕ CPU ಅನ್ನು ಹೊಂದಿದ್ದರೂ ಸಹ, OS ಬಹುತೇಕ ಅನಂತ ಸಂಖ್ಯೆಯ CPUಗಳ ಭ್ರಮೆಯನ್ನು ಹೇಗೆ ರಚಿಸಬಹುದು?

CPU ವರ್ಚುವಲೈಸೇಶನ್ ಮೂಲಕ OS ಈ ಭ್ರಮೆಯನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ. ಒಂದು ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪ್ರಾರಂಭಿಸುವ ಮೂಲಕ, ನಂತರ ಅದನ್ನು ನಿಲ್ಲಿಸುವ ಮೂಲಕ, ಇನ್ನೊಂದು ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪ್ರಾರಂಭಿಸುವ ಮೂಲಕ, OS ಹಲವು ವರ್ಚುವಲ್ CPU ಗಳು ಇವೆ ಎಂಬ ಭ್ರಮೆಯನ್ನು ನಿರ್ವಹಿಸಬಹುದು, ವಾಸ್ತವವಾಗಿ ಒಂದು ಅಥವಾ ಹೆಚ್ಚಿನ ಭೌತಿಕ ಪ್ರೊಸೆಸರ್‌ಗಳು ಇರುತ್ತವೆ. ಈ ತಂತ್ರವನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ ಸಮಯದ ಮೂಲಕ CPU ಸಂಪನ್ಮೂಲಗಳ ವಿಭಜನೆ. ಈ ತಂತ್ರವು ಬಳಕೆದಾರರು ಬಯಸಿದಷ್ಟು ಏಕಕಾಲೀನ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಚಲಾಯಿಸಲು ಅನುಮತಿಸುತ್ತದೆ. ಈ ಪರಿಹಾರದ ವೆಚ್ಚವು ಕಾರ್ಯಕ್ಷಮತೆಯಾಗಿದೆ - CPU ಅನ್ನು ಹಲವಾರು ಪ್ರಕ್ರಿಯೆಗಳಿಂದ ಹಂಚಿಕೊಂಡರೆ, ಪ್ರತಿ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಹೆಚ್ಚು ನಿಧಾನವಾಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲಾಗುತ್ತದೆ.
CPU ವರ್ಚುವಲೈಸೇಶನ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಮತ್ತು ವಿಶೇಷವಾಗಿ ಅದನ್ನು ಉತ್ತಮವಾಗಿ ಮಾಡಲು, OS ಗೆ ಕಡಿಮೆ ಮಟ್ಟದ ಮತ್ತು ಉನ್ನತ ಮಟ್ಟದ ಬೆಂಬಲದ ಅಗತ್ಯವಿದೆ. ಕಡಿಮೆ ಮಟ್ಟದ ಬೆಂಬಲವನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ ಕಾರ್ಯವಿಧಾನಗಳು ಕಾರ್ಯನಿರ್ವಹಣೆಯ ಅಗತ್ಯವಿರುವ ಭಾಗವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಕೆಳಮಟ್ಟದ ವಿಧಾನಗಳು ಅಥವಾ ಪ್ರೋಟೋಕಾಲ್‌ಗಳಾಗಿವೆ. ಅಂತಹ ಕಾರ್ಯಚಟುವಟಿಕೆಗೆ ಉದಾಹರಣೆಯೆಂದರೆ ಸಂದರ್ಭ ಸ್ವಿಚಿಂಗ್, ಇದು OS ಗೆ ಒಂದು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ನಿಲ್ಲಿಸಲು ಮತ್ತು ಪ್ರೊಸೆಸರ್ನಲ್ಲಿ ಮತ್ತೊಂದು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಚಲಾಯಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ನೀಡುತ್ತದೆ. ಈ ಸಮಯದ ವಿಭಾಗವನ್ನು ಎಲ್ಲಾ ಆಧುನಿಕ ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ಅಳವಡಿಸಲಾಗಿದೆ.
ಈ ಕಾರ್ಯವಿಧಾನಗಳ ಮೇಲೆ "ನೀತಿಗಳ" ರೂಪದಲ್ಲಿ OS ನಲ್ಲಿ ಕೆಲವು ತರ್ಕಗಳನ್ನು ನಿರ್ಮಿಸಲಾಗಿದೆ. ನೀತಿ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್‌ಗೆ ನಿರ್ದಿಷ್ಟ ನಿರ್ಧಾರ ತೆಗೆದುಕೊಳ್ಳುವ ಅಲ್ಗಾರಿದಮ್ ಆಗಿದೆ. ಅಂತಹ ನೀತಿಗಳು, ಉದಾಹರಣೆಗೆ, ಯಾವ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಪ್ರಾರಂಭಿಸಬೇಕು (ಕಮಾಂಡ್‌ಗಳ ಪಟ್ಟಿಯಿಂದ) ಮೊದಲು ನಿರ್ಧರಿಸಿ. ಆದ್ದರಿಂದ, ಉದಾಹರಣೆಗೆ, ಈ ಸಮಸ್ಯೆಯನ್ನು ಎಂಬ ನೀತಿಯಿಂದ ಪರಿಹರಿಸಲಾಗುತ್ತದೆ ಶೆಡ್ಯೂಲರ್ (ವೇಳಾಪಟ್ಟಿ ನೀತಿ) ಮತ್ತು ಪರಿಹಾರವನ್ನು ಆಯ್ಕೆಮಾಡುವಾಗ, ಇದು ಅಂತಹ ಡೇಟಾದಿಂದ ಮಾರ್ಗದರ್ಶಿಸಲ್ಪಡುತ್ತದೆ: ಆರಂಭಿಕ ಇತಿಹಾಸ (ಕೊನೆಯ ನಿಮಿಷಗಳಲ್ಲಿ ಯಾವ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ದೀರ್ಘವಾಗಿ ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ), ಈ ಪ್ರಕ್ರಿಯೆಯು ಯಾವ ಲೋಡ್ ಅನ್ನು ಹೊಂದಿರುತ್ತದೆ (ಯಾವ ರೀತಿಯ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ), ಕಾರ್ಯಕ್ಷಮತೆಯ ಮಾಪನಗಳು (ಸಿಸ್ಟಮ್ ಆಗಿರಲಿ ಸಂವಾದಾತ್ಮಕ ಸಂವಾದಕ್ಕಾಗಿ ಅಥವಾ ಥ್ರೋಪುಟ್‌ಗಾಗಿ ಹೊಂದುವಂತೆ ಮಾಡಲಾಗಿದೆ) ಮತ್ತು ಹೀಗೆ.

ಅಮೂರ್ತತೆ: ಪ್ರಕ್ರಿಯೆ

ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂನಿಂದ ಕಾರ್ಯಗತಗೊಳಿಸಲಾದ ಚಾಲನೆಯಲ್ಲಿರುವ ಪ್ರೋಗ್ರಾಂನ ಅಮೂರ್ತತೆಯನ್ನು ನಾವು ಕರೆಯುತ್ತೇವೆ ಪ್ರಕ್ರಿಯೆ. ಮೊದಲೇ ಹೇಳಿದಂತೆ, ಪ್ರಕ್ರಿಯೆಯು ಯಾವುದೇ ತತ್‌ಕ್ಷಣದ ಅವಧಿಯಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಪ್ರೋಗ್ರಾಂ ಆಗಿದೆ. ಈ ಪ್ರೋಗ್ರಾಂ ಪ್ರವೇಶಿಸುವ ಅಥವಾ ಅದರ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಮಯದಲ್ಲಿ ಪರಿಣಾಮ ಬೀರುವ ವಿವಿಧ ಸಿಸ್ಟಮ್ ಸಂಪನ್ಮೂಲಗಳಿಂದ ಸಾರಾಂಶ ಮಾಹಿತಿಯನ್ನು ನಾವು ಪಡೆಯುವ ಪ್ರೋಗ್ರಾಂ.
ಪ್ರಕ್ರಿಯೆಯ ಅಂಶಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ನೀವು ಸಿಸ್ಟಮ್ನ ಸ್ಥಿತಿಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕು: ಪ್ರೋಗ್ರಾಂ ಅದರ ಕಾರ್ಯಾಚರಣೆಯ ಸಮಯದಲ್ಲಿ ಏನು ಓದಬಹುದು ಅಥವಾ ಬದಲಾಯಿಸಬಹುದು. ಯಾವುದೇ ಸಮಯದಲ್ಲಿ, ಪ್ರೋಗ್ರಾಂನ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಸಿಸ್ಟಮ್ನ ಯಾವ ಅಂಶಗಳು ಮುಖ್ಯವೆಂದು ನೀವು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕು.
ಪ್ರಕ್ರಿಯೆಯು ಒಳಗೊಂಡಿರುವ ವ್ಯವಸ್ಥೆಯ ಸ್ಪಷ್ಟ ಅಂಶಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ ಪಾಮ. ಸೂಚನೆಗಳು ಮೆಮೊರಿಯಲ್ಲಿವೆ. ಪ್ರೋಗ್ರಾಂ ಓದುವ ಅಥವಾ ಬರೆಯುವ ಡೇಟಾವು ಮೆಮೊರಿಯಲ್ಲಿದೆ. ಹೀಗಾಗಿ, ಪ್ರಕ್ರಿಯೆಯು ಪರಿಹರಿಸಬಹುದಾದ ಮೆಮೊರಿ (ವಿಳಾಸ ಸ್ಥಳ ಎಂದು ಕರೆಯಲ್ಪಡುತ್ತದೆ) ಪ್ರಕ್ರಿಯೆಯ ಭಾಗವಾಗಿದೆ.
ಸಿಸ್ಟಮ್ ರಾಜ್ಯದ ಭಾಗವು ರೆಜಿಸ್ಟರ್‌ಗಳಾಗಿವೆ. ಅನೇಕ ಸೂಚನೆಗಳು ರೆಜಿಸ್ಟರ್‌ಗಳ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸುವ ಅಥವಾ ಅವುಗಳ ಮೌಲ್ಯವನ್ನು ಓದುವ ಗುರಿಯನ್ನು ಹೊಂದಿವೆ, ಹೀಗಾಗಿ ರೆಜಿಸ್ಟರ್‌ಗಳು ಪ್ರಕ್ರಿಯೆಯ ಕಾರ್ಯಾಚರಣೆಯ ಪ್ರಮುಖ ಭಾಗವಾಗುತ್ತವೆ.
ಕೆಲವು ವಿಶೇಷ ರೆಜಿಸ್ಟರ್‌ಗಳಿಂದ ಯಂತ್ರ ಸ್ಥಿತಿ ಕೂಡ ರೂಪುಗೊಂಡಿದೆ ಎಂದು ಗಮನಿಸಬೇಕು. ಉದಾಹರಣೆಗೆ, ಐಪಿ - ಸೂಚನಾ ಪಾಯಿಂಟರ್ - ಪ್ರೋಗ್ರಾಂ ಪ್ರಸ್ತುತ ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತಿರುವ ಸೂಚನೆಯ ಪಾಯಿಂಟರ್. ಕೂಡ ಇದೆ ಸ್ಟಾಕ್ ಪಾಯಿಂಟರ್ ಮತ್ತು ಅದಕ್ಕೆ ಸಂಬಂಧಿಸಿದೆ ಫ್ರೇಮ್ ಪಾಯಿಂಟರ್, ಇವುಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ: ಫಂಕ್ಷನ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳು, ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್‌ಗಳು ಮತ್ತು ರಿಟರ್ನ್ ವಿಳಾಸಗಳು.
ಅಂತಿಮವಾಗಿ, ಪ್ರೋಗ್ರಾಂಗಳು ಸಾಮಾನ್ಯವಾಗಿ ROM ಅನ್ನು ಪ್ರವೇಶಿಸುತ್ತವೆ (ಓದಲು-ಮಾತ್ರ ಮೆಮೊರಿ). ಈ "I/O" (ಇನ್‌ಪುಟ್/ಔಟ್‌ಪುಟ್) ಮಾಹಿತಿಯು ಪ್ರಕ್ರಿಯೆಯಿಂದ ಪ್ರಸ್ತುತ ತೆರೆದಿರುವ ಫೈಲ್‌ಗಳ ಪಟ್ಟಿಯನ್ನು ಒಳಗೊಂಡಿರಬೇಕು.

ಪ್ರಕ್ರಿಯೆ API

ಪ್ರಕ್ರಿಯೆಯು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದರ ಕುರಿತು ನಮ್ಮ ತಿಳುವಳಿಕೆಯನ್ನು ಸುಧಾರಿಸಲು, ಯಾವುದೇ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಇಂಟರ್ಫೇಸ್ನಲ್ಲಿ ಸೇರಿಸಬೇಕಾದ ಸಿಸ್ಟಮ್ ಕರೆಗಳ ಉದಾಹರಣೆಗಳನ್ನು ಅಧ್ಯಯನ ಮಾಡೋಣ. ಈ API ಗಳು ಯಾವುದೇ OS ನಲ್ಲಿ ಒಂದಲ್ಲ ಒಂದು ರೂಪದಲ್ಲಿ ಲಭ್ಯವಿದೆ.

● ರಚಿಸಿ (ಸೃಷ್ಟಿ): ಹೊಸ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ರಚಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುವ ಕೆಲವು ವಿಧಾನವನ್ನು OS ಒಳಗೊಂಡಿರಬೇಕು. ನೀವು ಟರ್ಮಿನಲ್‌ಗೆ ಆಜ್ಞೆಯನ್ನು ನಮೂದಿಸಿದಾಗ ಅಥವಾ ಐಕಾನ್ ಮೇಲೆ ಡಬಲ್ ಕ್ಲಿಕ್ ಮಾಡುವ ಮೂಲಕ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿದಾಗ, ಹೊಸ ಪ್ರಕ್ರಿಯೆಯನ್ನು ರಚಿಸಲು ಮತ್ತು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲು OS ಗೆ ಕರೆಯನ್ನು ಕಳುಹಿಸಲಾಗುತ್ತದೆ.
● ಅಳಿಸಿ: ಪ್ರಕ್ರಿಯೆಯನ್ನು ರಚಿಸಲು ಇಂಟರ್ಫೇಸ್ ಇರುವುದರಿಂದ, OS ಪ್ರಕ್ರಿಯೆಯನ್ನು ತೆಗೆದುಹಾಕಲು ಒತ್ತಾಯಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಸಹ ಒದಗಿಸಬೇಕು. ಹೆಚ್ಚಿನ ಕಾರ್ಯಕ್ರಮಗಳು ಸ್ವಾಭಾವಿಕವಾಗಿ ಪ್ರಾರಂಭವಾಗುತ್ತವೆ ಮತ್ತು ಅವುಗಳು ಚಾಲನೆಯಲ್ಲಿರುವಾಗ ತಮ್ಮದೇ ಆದ ಮೇಲೆ ಕೊನೆಗೊಳ್ಳುತ್ತವೆ. ಇಲ್ಲದಿದ್ದರೆ ಬಳಕೆದಾರರು ಅವರನ್ನು ಕೊಲ್ಲಲು ಬಯಸುತ್ತಾರೆ ಮತ್ತು ಹೀಗಾಗಿ ಪ್ರಕ್ರಿಯೆಯನ್ನು ನಿಲ್ಲಿಸಲು ಇಂಟರ್ಫೇಸ್ ಉಪಯುಕ್ತವಾಗಿರುತ್ತದೆ.
● ನಿರೀಕ್ಷಿಸಿ (ಕಾಯುವುದು): ಕೆಲವೊಮ್ಮೆ ಪ್ರಕ್ರಿಯೆಯು ಪೂರ್ಣಗೊಳ್ಳುವವರೆಗೆ ಕಾಯುವುದು ಉಪಯುಕ್ತವಾಗಿದೆ, ಆದ್ದರಿಂದ ಕಾಯುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಒದಗಿಸುವ ಕೆಲವು ಇಂಟರ್ಫೇಸ್‌ಗಳನ್ನು ಒದಗಿಸಲಾಗಿದೆ.
● ಇತರೆ ನಿಯಂತ್ರಣ (ವಿವಿಧ ನಿಯಂತ್ರಣ): ಕೊಲ್ಲುವ ಮತ್ತು ಪ್ರಕ್ರಿಯೆಗಾಗಿ ಕಾಯುವುದರ ಜೊತೆಗೆ, ಇತರ ವಿವಿಧ ನಿಯಂತ್ರಣ ವಿಧಾನಗಳೂ ಇವೆ. ಉದಾಹರಣೆಗೆ, ಹೆಚ್ಚಿನ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂಗಳು ಪ್ರಕ್ರಿಯೆಯನ್ನು ಫ್ರೀಜ್ ಮಾಡುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಒದಗಿಸುತ್ತದೆ (ನಿರ್ದಿಷ್ಟ ಅವಧಿಗೆ ಅದರ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ನಿಲ್ಲಿಸಿ) ಮತ್ತು ನಂತರ ಅದನ್ನು ಪುನರಾರಂಭಿಸಿ (ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಮುಂದುವರಿಸಿ)
● ಸ್ಥಿತಿ (ರಾಜ್ಯ): ಪ್ರಕ್ರಿಯೆಯ ಸ್ಥಿತಿಯ ಕುರಿತು ಕೆಲವು ಮಾಹಿತಿಯನ್ನು ಪಡೆಯಲು ವಿವಿಧ ಇಂಟರ್ಫೇಸ್‌ಗಳಿವೆ, ಉದಾಹರಣೆಗೆ ಅದು ಎಷ್ಟು ಸಮಯ ಚಾಲನೆಯಲ್ಲಿದೆ ಅಥವಾ ಪ್ರಸ್ತುತ ಯಾವ ಸ್ಥಿತಿಯಲ್ಲಿದೆ.

ಪ್ರಕ್ರಿಯೆ ರಚನೆ: ವಿವರಗಳು

ಒಂದು ಕುತೂಹಲಕಾರಿ ಸಂಗತಿಯೆಂದರೆ, ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ಹೇಗೆ ನಿಖರವಾಗಿ ಪ್ರಕ್ರಿಯೆಗಳಾಗಿ ಪರಿವರ್ತಿಸಲಾಗುತ್ತದೆ. ವಿಶೇಷವಾಗಿ OS ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಹೇಗೆ ಎತ್ತಿಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ರನ್ ಮಾಡುತ್ತದೆ. ಪ್ರಕ್ರಿಯೆಯನ್ನು ಹೇಗೆ ನಿಖರವಾಗಿ ರಚಿಸಲಾಗಿದೆ.
ಮೊದಲನೆಯದಾಗಿ, ಓಎಸ್ ಪ್ರೋಗ್ರಾಂ ಕೋಡ್ ಮತ್ತು ಸ್ಥಿರ ಡೇಟಾವನ್ನು ಮೆಮೊರಿಗೆ ಲೋಡ್ ಮಾಡಬೇಕು (ಪ್ರಕ್ರಿಯೆಯ ವಿಳಾಸ ಜಾಗಕ್ಕೆ). ಪ್ರೋಗ್ರಾಂಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಡಿಸ್ಕ್ ಅಥವಾ ಘನ-ಸ್ಥಿತಿಯ ಡ್ರೈವಿನಲ್ಲಿ ಕೆಲವು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಸ್ವರೂಪದಲ್ಲಿ ನೆಲೆಗೊಂಡಿವೆ. ಹೀಗಾಗಿ, ಮೆಮೊರಿಗೆ ಪ್ರೋಗ್ರಾಂ ಮತ್ತು ಸ್ಥಿರ ಡೇಟಾವನ್ನು ಲೋಡ್ ಮಾಡುವ ಪ್ರಕ್ರಿಯೆಯು OS ಗೆ ಆ ಬೈಟ್‌ಗಳನ್ನು ಡಿಸ್ಕ್‌ನಿಂದ ಓದಲು ಮತ್ತು ಮೆಮೊರಿಯಲ್ಲಿ ಎಲ್ಲೋ ಇರಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.

ಆರಂಭಿಕ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂಗಳಲ್ಲಿ, ಲೋಡಿಂಗ್ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಉತ್ಸಾಹದಿಂದ ಮಾಡಲಾಯಿತು, ಅಂದರೆ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು ಸಂಪೂರ್ಣ ಕೋಡ್ ಅನ್ನು ಮೆಮೊರಿಗೆ ಲೋಡ್ ಮಾಡಲಾಗಿದೆ. ಆಧುನಿಕ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂಗಳು ಇದನ್ನು ಸೋಮಾರಿಯಾಗಿ ಮಾಡುತ್ತವೆ, ಅಂದರೆ, ಪ್ರೋಗ್ರಾಂ ಅದರ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯ ಸಮಯದಲ್ಲಿ ಅಗತ್ಯವಿರುವಾಗ ಮಾತ್ರ ಕೋಡ್ ಅಥವಾ ಡೇಟಾದ ತುಣುಕುಗಳನ್ನು ಲೋಡ್ ಮಾಡುತ್ತದೆ.

ಕೋಡ್ ಮತ್ತು ಸ್ಥಿರ ಡೇಟಾವನ್ನು OS ಮೆಮೊರಿಗೆ ಲೋಡ್ ಮಾಡಿದ ನಂತರ, ಪ್ರಕ್ರಿಯೆಯು ರನ್ ಆಗುವ ಮೊದಲು ಇನ್ನೂ ಕೆಲವು ಕೆಲಸಗಳನ್ನು ಮಾಡಬೇಕಾಗಿದೆ. ಸ್ಟಾಕ್‌ಗಾಗಿ ಸ್ವಲ್ಪ ಪ್ರಮಾಣದ ಮೆಮೊರಿಯನ್ನು ನಿಯೋಜಿಸಬೇಕು. ಪ್ರೋಗ್ರಾಂಗಳು ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್‌ಗಳು, ಫಂಕ್ಷನ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳು ಮತ್ತು ರಿಟರ್ನ್ ವಿಳಾಸಗಳಿಗಾಗಿ ಸ್ಟಾಕ್ ಅನ್ನು ಬಳಸುತ್ತವೆ. OS ಈ ಮೆಮೊರಿಯನ್ನು ನಿಯೋಜಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಪ್ರಕ್ರಿಯೆಗೆ ನೀಡುತ್ತದೆ. ಸ್ಟಾಕ್ ಅನ್ನು ಕೆಲವು ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳೊಂದಿಗೆ ಹಂಚಬಹುದು, ನಿರ್ದಿಷ್ಟವಾಗಿ ಇದು ಮುಖ್ಯ() ಫಂಕ್ಷನ್‌ನ ನಿಯತಾಂಕಗಳನ್ನು ತುಂಬುತ್ತದೆ, ಉದಾಹರಣೆಗೆ argc ಮತ್ತು argv ಯ ಒಂದು ಶ್ರೇಣಿಯೊಂದಿಗೆ.

ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಪ್ರೋಗ್ರಾಂ ಹೀಪ್‌ಗೆ ಕೆಲವು ಮೆಮೊರಿಯನ್ನು ಸಹ ನಿಯೋಜಿಸಬಹುದು. ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ನಿಯೋಜಿಸಲಾದ ಡೇಟಾವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ವಿನಂತಿಸಲು ಪ್ರೋಗ್ರಾಂಗಳಿಂದ ರಾಶಿಯನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಕಾರ್ಯವನ್ನು ಕರೆಯುವ ಮೂಲಕ ಪ್ರೋಗ್ರಾಂಗಳು ಈ ಜಾಗವನ್ನು ವಿನಂತಿಸುತ್ತವೆ malloc () ಮತ್ತು ಕಾರ್ಯವನ್ನು ಕರೆಯುವ ಮೂಲಕ ಅದನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ತೆರವುಗೊಳಿಸುತ್ತದೆ ಉಚಿತ (). ಲಿಂಕ್ಡ್ ಶೀಟ್‌ಗಳು, ಹ್ಯಾಶ್ ಟೇಬಲ್‌ಗಳು, ಮರಗಳು ಮತ್ತು ಇತರವುಗಳಂತಹ ಡೇಟಾ ರಚನೆಗಳಿಗೆ ರಾಶಿ ಅಗತ್ಯವಿದೆ. ಮೊದಲಿಗೆ, ಸ್ವಲ್ಪ ಪ್ರಮಾಣದ ಮೆಮೊರಿಯನ್ನು ರಾಶಿಗೆ ಹಂಚಲಾಗುತ್ತದೆ, ಆದರೆ ಕಾಲಾನಂತರದಲ್ಲಿ, ಪ್ರೋಗ್ರಾಂ ಚಾಲನೆಯಲ್ಲಿರುವಂತೆ, ರಾಶಿಯು ಲೈಬ್ರರಿ API ಕರೆ malloc() ಮೂಲಕ ಹೆಚ್ಚಿನ ಮೆಮೊರಿಯನ್ನು ವಿನಂತಿಸಬಹುದು. ಈ ಕರೆಗಳನ್ನು ಪೂರೈಸಲು ಹೆಚ್ಚಿನ ಮೆಮೊರಿಯನ್ನು ನಿಯೋಜಿಸುವ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ತೊಡಗಿಸಿಕೊಂಡಿದೆ.

ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಆರಂಭಿಕ ಕಾರ್ಯಗಳನ್ನು ಸಹ ನಿರ್ವಹಿಸುತ್ತದೆ, ವಿಶೇಷವಾಗಿ I/O ಗೆ ಸಂಬಂಧಿಸಿದವು. ಉದಾಹರಣೆಗೆ, UNIX ಸಿಸ್ಟಮ್‌ಗಳಲ್ಲಿ, ಪ್ರತಿ ಪ್ರಕ್ರಿಯೆಯು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ 3 ತೆರೆದ ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್‌ಗಳನ್ನು ಹೊಂದಿದೆ, ಪ್ರಮಾಣಿತ ಇನ್‌ಪುಟ್, ಔಟ್‌ಪುಟ್ ಮತ್ತು ದೋಷಕ್ಕಾಗಿ. ಈ ಹ್ಯಾಂಡಲ್‌ಗಳು ಟರ್ಮಿನಲ್‌ನಿಂದ ಇನ್‌ಪುಟ್ ಅನ್ನು ಓದಲು ಮತ್ತು ಪರದೆಯ ಮೇಲೆ ಮಾಹಿತಿಯನ್ನು ಪ್ರದರ್ಶಿಸಲು ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ಅನುಮತಿಸುತ್ತದೆ.

ಹೀಗಾಗಿ, ಕೋಡ್ ಮತ್ತು ಸ್ಥಿರ ಡೇಟಾವನ್ನು ಮೆಮೊರಿಗೆ ಲೋಡ್ ಮಾಡುವ ಮೂಲಕ, ಸ್ಟಾಕ್ ಅನ್ನು ರಚಿಸುವ ಮತ್ತು ಪ್ರಾರಂಭಿಸುವ ಮೂಲಕ ಮತ್ತು I/O ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಸಂಬಂಧಿಸಿದ ಇತರ ಕೆಲಸವನ್ನು ಮಾಡುವ ಮೂಲಕ, OS ಪ್ರಕ್ರಿಯೆಯು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಹಂತವನ್ನು ಸಿದ್ಧಪಡಿಸುತ್ತದೆ. ಅಂತಿಮವಾಗಿ, ಒಂದು ಕೊನೆಯ ಕಾರ್ಯ ಉಳಿದಿದೆ: ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಅದರ ಪ್ರವೇಶ ಬಿಂದುವಿನ ಮೂಲಕ ಚಾಲನೆ ಮಾಡುವುದು, ಇದನ್ನು ಮುಖ್ಯ() ಫಂಕ್ಷನ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಮುಖ್ಯ() ಕಾರ್ಯವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಮೂಲಕ, OS ಸಿಪಿಯು ನಿಯಂತ್ರಣವನ್ನು ಹೊಸದಾಗಿ ರಚಿಸಲಾದ ಪ್ರಕ್ರಿಯೆಗೆ ವರ್ಗಾಯಿಸುತ್ತದೆ, ಹೀಗಾಗಿ ಪ್ರೋಗ್ರಾಂ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ.

ಪ್ರಕ್ರಿಯೆಯ ಸ್ಥಿತಿ

ಈಗ ನಾವು ಪ್ರಕ್ರಿಯೆ ಎಂದರೇನು ಮತ್ತು ಅದನ್ನು ಹೇಗೆ ರಚಿಸಲಾಗಿದೆ ಎಂಬುದರ ಕುರಿತು ಸ್ವಲ್ಪ ತಿಳುವಳಿಕೆಯನ್ನು ಹೊಂದಿದ್ದೇವೆ, ಅದು ಇರಬಹುದಾದ ಪ್ರಕ್ರಿಯೆಯ ಸ್ಥಿತಿಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡೋಣ. ಅದರ ಸರಳ ರೂಪದಲ್ಲಿ, ಪ್ರಕ್ರಿಯೆಯು ಈ ಕೆಳಗಿನ ರಾಜ್ಯಗಳಲ್ಲಿ ಒಂದಾಗಿರಬಹುದು:
● ರನ್ನಿಂಗ್. ಚಾಲನೆಯಲ್ಲಿರುವಾಗ, ಪ್ರಕ್ರಿಯೆಯು ಪ್ರೊಸೆಸರ್ನಲ್ಲಿ ಚಲಿಸುತ್ತದೆ. ಇದರರ್ಥ ಸೂಚನೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತಿದೆ.
● ರೆಡಿ. ಸಿದ್ಧ ಸ್ಥಿತಿಯಲ್ಲಿ, ಪ್ರಕ್ರಿಯೆಯು ಚಲಾಯಿಸಲು ಸಿದ್ಧವಾಗಿದೆ, ಆದರೆ ಕೆಲವು ಕಾರಣಗಳಿಂದ OS ನಿರ್ದಿಷ್ಟ ಸಮಯದಲ್ಲಿ ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದಿಲ್ಲ.
● ನಿರ್ಬಂಧಿಸಿದ. ನಿರ್ಬಂಧಿಸಲಾದ ಸ್ಥಿತಿಯಲ್ಲಿ, ಪ್ರಕ್ರಿಯೆಯು ಕೆಲವು ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ, ಅದು ಕೆಲವು ಘಟನೆಗಳು ಸಂಭವಿಸುವವರೆಗೆ ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಸಿದ್ಧವಾಗುವುದನ್ನು ತಡೆಯುತ್ತದೆ. ಒಂದು ಸಾಮಾನ್ಯ ಉದಾಹರಣೆಯೆಂದರೆ, ಒಂದು ಪ್ರಕ್ರಿಯೆಯು IO ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಪ್ರಾರಂಭಿಸಿದಾಗ, ಅದು ನಿರ್ಬಂಧಿಸಲ್ಪಡುತ್ತದೆ ಇದರಿಂದ ಕೆಲವು ಇತರ ಪ್ರಕ್ರಿಯೆಗಳು ಪ್ರೊಸೆಸರ್ ಅನ್ನು ಬಳಸಬಹುದು.

ನೀವು ಈ ರಾಜ್ಯಗಳನ್ನು ಗ್ರಾಫ್ ರೂಪದಲ್ಲಿ ಕಲ್ಪಿಸಿಕೊಳ್ಳಬಹುದು. ನಾವು ಚಿತ್ರದಲ್ಲಿ ನೋಡುವಂತೆ, OS ನ ವಿವೇಚನೆಯಿಂದ ಪ್ರಕ್ರಿಯೆಯ ಸ್ಥಿತಿಯು ರನ್ನಿಂಗ್ ಮತ್ತು ರೆಡಿ ನಡುವೆ ಬದಲಾಗಬಹುದು. ಪ್ರಕ್ರಿಯೆಯ ಸ್ಥಿತಿಯು READY ನಿಂದ RUNNING ಗೆ ಬದಲಾದಾಗ, ಪ್ರಕ್ರಿಯೆಯನ್ನು ನಿಗದಿಪಡಿಸಲಾಗಿದೆ ಎಂದರ್ಥ. ವಿರುದ್ಧ ದಿಕ್ಕಿನಲ್ಲಿ - ಲೇಔಟ್ನಿಂದ ತೆಗೆದುಹಾಕಲಾಗಿದೆ. ಒಂದು ಪ್ರಕ್ರಿಯೆಯು ನಿರ್ಬಂಧಿಸಲ್ಪಟ್ಟ ಕ್ಷಣದಲ್ಲಿ, ಉದಾಹರಣೆಗೆ, ನಾನು IO ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತೇನೆ, ಕೆಲವು ಘಟನೆಗಳು ಸಂಭವಿಸುವವರೆಗೆ OS ಅದನ್ನು ಈ ಸ್ಥಿತಿಯಲ್ಲಿರಿಸುತ್ತದೆ, ಉದಾಹರಣೆಗೆ IO ಪೂರ್ಣಗೊಳ್ಳುವವರೆಗೆ. ಈ ಕ್ಷಣದಲ್ಲಿ READY ಸ್ಥಿತಿಗೆ ಪರಿವರ್ತನೆ ಮತ್ತು ಪ್ರಾಯಶಃ ತಕ್ಷಣವೇ ರನ್ನಿಂಗ್ ಸ್ಥಿತಿಗೆ OS ನಿರ್ಧರಿಸಿದರೆ.
ಈ ರಾಜ್ಯಗಳ ಮೂಲಕ ಎರಡು ಪ್ರಕ್ರಿಯೆಗಳು ಹೇಗೆ ಚಲಿಸುತ್ತವೆ ಎಂಬುದರ ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ. ಪ್ರಾರಂಭಿಸಲು, ಎರಡೂ ಪ್ರಕ್ರಿಯೆಗಳು ಚಾಲನೆಯಲ್ಲಿವೆ ಮತ್ತು ಪ್ರತಿಯೊಂದೂ CPU ಅನ್ನು ಮಾತ್ರ ಬಳಸುತ್ತಿದೆ ಎಂದು ಊಹಿಸೋಣ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಅವರ ರಾಜ್ಯಗಳು ಈ ರೀತಿ ಕಾಣುತ್ತವೆ.

ಕೆಳಗಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, ಮೊದಲ ಪ್ರಕ್ರಿಯೆಯು, ಸ್ವಲ್ಪ ಸಮಯದ ಚಾಲನೆಯ ನಂತರ, IO ಅನ್ನು ವಿನಂತಿಸುತ್ತದೆ ಮತ್ತು ನಿರ್ಬಂಧಿಸಲಾದ ಸ್ಥಿತಿಯನ್ನು ಪ್ರವೇಶಿಸುತ್ತದೆ, ಮತ್ತೊಂದು ಪ್ರಕ್ರಿಯೆಯನ್ನು ಚಲಾಯಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ (FIG 1.4). ಪ್ರಕ್ರಿಯೆ 0 CPU ಅನ್ನು ಬಳಸುತ್ತಿಲ್ಲ ಎಂದು OS ನೋಡುತ್ತದೆ ಮತ್ತು ಪ್ರಕ್ರಿಯೆ 1 ಅನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ. ಪ್ರಕ್ರಿಯೆ 1 ಚಾಲನೆಯಲ್ಲಿರುವಾಗ, IO ಪೂರ್ಣಗೊಂಡಿದೆ ಮತ್ತು ಪ್ರಕ್ರಿಯೆ 0 ನ ಸ್ಥಿತಿಯು READY ಗೆ ಬದಲಾಗುತ್ತದೆ. ಅಂತಿಮವಾಗಿ, ಪ್ರಕ್ರಿಯೆ 1 ಪೂರ್ಣಗೊಂಡಿದೆ ಮತ್ತು ಪೂರ್ಣಗೊಂಡ ನಂತರ, ಪ್ರಕ್ರಿಯೆ 0 ಪ್ರಾರಂಭವಾಗುತ್ತದೆ, ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಅದರ ಕೆಲಸವನ್ನು ಪೂರ್ಣಗೊಳಿಸುತ್ತದೆ.

ಡೇಟಾ ರಚನೆ

OS ಸ್ವತಃ ಒಂದು ಪ್ರೋಗ್ರಾಂ ಆಗಿದೆ, ಮತ್ತು ಯಾವುದೇ ಇತರ ಪ್ರೋಗ್ರಾಂನಂತೆ, ಇದು ಕೆಲವು ಪ್ರಮುಖ ಡೇಟಾ ರಚನೆಗಳನ್ನು ಹೊಂದಿದೆ, ಅದು ವಿವಿಧ ಸಂಬಂಧಿತ ಮಾಹಿತಿಯ ತುಣುಕುಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುತ್ತದೆ. ಪ್ರತಿ ಪ್ರಕ್ರಿಯೆಯ ಸ್ಥಿತಿಯನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು, OS ಕೆಲವನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ ಪ್ರಕ್ರಿಯೆ ಪಟ್ಟಿ READY ಸ್ಥಿತಿಯಲ್ಲಿರುವ ಎಲ್ಲಾ ಪ್ರಕ್ರಿಯೆಗಳಿಗೆ ಮತ್ತು ಪ್ರಸ್ತುತ ಚಾಲನೆಯಲ್ಲಿರುವ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಕೆಲವು ಹೆಚ್ಚುವರಿ ಮಾಹಿತಿಗಾಗಿ. ಅಲ್ಲದೆ, OS ನಿರ್ಬಂಧಿಸಿದ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಬೇಕು. IO ಪೂರ್ಣಗೊಂಡ ನಂತರ, OS ಅಗತ್ಯವಿರುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಎಚ್ಚರಗೊಳಿಸಬೇಕು ಮತ್ತು ಅದನ್ನು ಚಲಾಯಿಸಲು ಸಿದ್ಧ ಸ್ಥಿತಿಯಲ್ಲಿ ಇರಿಸಬೇಕು.

ಉದಾಹರಣೆಗೆ, OS ಪ್ರೊಸೆಸರ್ ರೆಜಿಸ್ಟರ್‌ಗಳ ಸ್ಥಿತಿಯನ್ನು ಸಂರಕ್ಷಿಸಬೇಕು. ಪ್ರಕ್ರಿಯೆಯು ನಿಲ್ಲುವ ಕ್ಷಣದಲ್ಲಿ, ರೆಜಿಸ್ಟರ್‌ಗಳ ಸ್ಥಿತಿಯನ್ನು ಪ್ರಕ್ರಿಯೆಯ ವಿಳಾಸ ಜಾಗದಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಅದರ ಕಾರ್ಯಾಚರಣೆಯು ಮುಂದುವರಿಯುವ ಕ್ಷಣದಲ್ಲಿ, ರೆಜಿಸ್ಟರ್‌ಗಳ ಮೌಲ್ಯಗಳನ್ನು ಪುನಃಸ್ಥಾಪಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಹೀಗಾಗಿ ಈ ಪ್ರಕ್ರಿಯೆಯ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಮುಂದುವರಿಸಲಾಗುತ್ತದೆ.

ಸಿದ್ಧ, ನಿರ್ಬಂಧಿಸಿದ, ಚಾಲನೆಯಲ್ಲಿರುವ ರಾಜ್ಯಗಳ ಜೊತೆಗೆ, ಇನ್ನೂ ಕೆಲವು ರಾಜ್ಯಗಳಿವೆ. ಕೆಲವೊಮ್ಮೆ, ರಚನೆಯ ಸಮಯದಲ್ಲಿ, ಒಂದು ಪ್ರಕ್ರಿಯೆಯು INIT ಸ್ಥಿತಿಯಲ್ಲಿರಬಹುದು. ಅಂತಿಮವಾಗಿ, ಪ್ರಕ್ರಿಯೆಯು ಈಗಾಗಲೇ ಪೂರ್ಣಗೊಂಡಾಗ ಅದನ್ನು ಅಂತಿಮ ಸ್ಥಿತಿಯಲ್ಲಿ ಇರಿಸಬಹುದು, ಆದರೆ ಅದರ ಮಾಹಿತಿಯನ್ನು ಇನ್ನೂ ತೆರವುಗೊಳಿಸಲಾಗಿಲ್ಲ. UNIX ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ಈ ಸ್ಥಿತಿಯನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ ಜೊಂಬಿ ಪ್ರಕ್ರಿಯೆ. ಪೋಷಕರ ಪ್ರಕ್ರಿಯೆಯು ಮಗುವಿನ ರಿಟರ್ನ್ ಕೋಡ್ ಅನ್ನು ತಿಳಿದುಕೊಳ್ಳಲು ಬಯಸುವ ಸಂದರ್ಭಗಳಲ್ಲಿ ಈ ಸ್ಥಿತಿಯು ಉಪಯುಕ್ತವಾಗಿದೆ, ಉದಾಹರಣೆಗೆ, ಸಾಮಾನ್ಯವಾಗಿ 0 ಯಶಸ್ಸನ್ನು ಮತ್ತು 1 ದೋಷವನ್ನು ಸಂಕೇತಿಸುತ್ತದೆ, ಆದರೆ ಪ್ರೋಗ್ರಾಮರ್ಗಳು ವಿಭಿನ್ನ ಸಮಸ್ಯೆಗಳನ್ನು ಸೂಚಿಸಲು ಹೆಚ್ಚುವರಿ ಔಟ್‌ಪುಟ್ ಕೋಡ್‌ಗಳನ್ನು ನೀಡಬಹುದು. ಪೋಷಕ ಪ್ರಕ್ರಿಯೆಯು ಕೊನೆಗೊಂಡಾಗ, ಇದು ವೇಯ್ಟ್() ನಂತಹ ಅಂತಿಮ ಸಿಸ್ಟಂ ಕರೆಯನ್ನು ಮಾಡುತ್ತದೆ, ಮಗುವಿನ ಪ್ರಕ್ರಿಯೆಯು ಕೊನೆಗೊಳ್ಳುವವರೆಗೆ ಕಾಯುತ್ತದೆ ಮತ್ತು ಮುಕ್ತಾಯಗೊಂಡ ಪ್ರಕ್ರಿಯೆಗೆ ಸಂಬಂಧಿಸಿದ ಯಾವುದೇ ಡೇಟಾವನ್ನು ಅದು ತೆರವುಗೊಳಿಸಬಹುದು ಎಂದು OS ಗೆ ಸಂಕೇತಿಸುತ್ತದೆ.

ಉಪನ್ಯಾಸದ ಪ್ರಮುಖ ಅಂಶಗಳು:

● ಪ್ರಕ್ರಿಯೆ - OS ನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಪ್ರೋಗ್ರಾಂನ ಮುಖ್ಯ ಸಾರಾಂಶ. ಯಾವುದೇ ಸಮಯದಲ್ಲಿ, ಪ್ರಕ್ರಿಯೆಯನ್ನು ಅದರ ಸ್ಥಿತಿಯಿಂದ ವಿವರಿಸಬಹುದು: ಅದರ ವಿಳಾಸ ಜಾಗದಲ್ಲಿನ ಮೆಮೊರಿಯ ವಿಷಯಗಳು, ಸೂಚನಾ ಪಾಯಿಂಟರ್ ಮತ್ತು ಸ್ಟಾಕ್ ಪಾಯಿಂಟರ್ ಸೇರಿದಂತೆ ಪ್ರೊಸೆಸರ್ ರೆಜಿಸ್ಟರ್‌ಗಳ ವಿಷಯಗಳು ಮತ್ತು ತೆರೆದ ಫೈಲ್‌ಗಳನ್ನು ಓದುವುದು ಅಥವಾ ಬರೆಯುವುದು ಮುಂತಾದ IO ಮಾಹಿತಿ.
● ಪ್ರಕ್ರಿಯೆ API ಪ್ರೋಗ್ರಾಂಗಳು ಪ್ರಕ್ರಿಯೆಗಳಿಗೆ ಮಾಡಬಹುದಾದ ಕರೆಗಳನ್ನು ಒಳಗೊಂಡಿದೆ. ವಿಶಿಷ್ಟವಾಗಿ ಇವುಗಳನ್ನು ರಚಿಸುವುದು, ಅಳಿಸುವುದು ಅಥವಾ ಇತರ ಕರೆಗಳು.
● ಪ್ರಕ್ರಿಯೆಯು ಚಾಲನೆಯಲ್ಲಿದೆ, ಸಿದ್ಧವಾಗಿದೆ, ನಿರ್ಬಂಧಿಸಲಾಗಿದೆ ಸೇರಿದಂತೆ ಹಲವು ರಾಜ್ಯಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. ಶೆಡ್ಯೂಲಿಂಗ್, ಶೆಡ್ಯೂಲಿಂಗ್‌ನಿಂದ ವಿನಾಯಿತಿಗಳು ಅಥವಾ ಕಾಯುವಿಕೆಗಳಂತಹ ವಿವಿಧ ಘಟನೆಗಳು ಪ್ರಕ್ರಿಯೆಯ ಸ್ಥಿತಿಯನ್ನು ಒಂದರಿಂದ ಇನ್ನೊಂದಕ್ಕೆ ಬದಲಾಯಿಸಬಹುದು.
● ಪ್ರಕ್ರಿಯೆ ಪಟ್ಟಿ ವ್ಯವಸ್ಥೆಯಲ್ಲಿನ ಎಲ್ಲಾ ಪ್ರಕ್ರಿಯೆಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಒಳಗೊಂಡಿದೆ. ಅದರಲ್ಲಿರುವ ಪ್ರತಿಯೊಂದು ಪ್ರವೇಶವನ್ನು ಪ್ರಕ್ರಿಯೆ ನಿಯಂತ್ರಣ ಬ್ಲಾಕ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ, ಇದು ವಾಸ್ತವದಲ್ಲಿ ಒಂದು ನಿರ್ದಿಷ್ಟ ಪ್ರಕ್ರಿಯೆಯ ಬಗ್ಗೆ ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ಮಾಹಿತಿಯನ್ನು ಒಳಗೊಂಡಿರುವ ರಚನೆಯಾಗಿದೆ. 

ಮೂಲ: www.habr.com