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

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

ಈ ವಿಷಯದ ಕುರಿತು ಲ್ಯಾಬ್ ಕೆಲಸವನ್ನು ಇಲ್ಲಿ ಕಾಣಬಹುದು:
- ಮೂಲ: pages.cs.wisc.edu/~remzi/OSTEP/Homework/homework.html
- ಮೂಲ: github.com/remzi-arpacidusseau/ostep-code
- ನನ್ನ ವೈಯಕ್ತಿಕ ರೂಪಾಂತರ: github.com/bykvaadm/OS/tree/master/ostep

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

ಕಾರ್ಯಕ್ರಮದ ಕಾರ್ಯಾಚರಣೆ

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

ವಾನ್ ನ್ಯೂಮನ್ ಕಂಪ್ಯೂಟೇಶನ್ ಮಾದರಿ

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

ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್

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

CPU ವರ್ಚುವಲೈಸೇಶನ್

ಕೆಳಗಿನ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಪರಿಗಣಿಸಿ:
(https://www.youtube.com/watch?v=zDwT5fUcki4&feature=youtu.be)

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

ಮೆಮೊರಿ ವರ್ಚುವಲೈಸೇಶನ್

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

malloc() ಗೆ ಕರೆ ಮಾಡಲಾಗುತ್ತಿದೆ

ಕೆಳಗಿನ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಪರಿಗಣಿಸಿ, ಇದು ಕರೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಮೆಮೊರಿಯ ಪ್ರದೇಶವನ್ನು ನಿಯೋಜಿಸುತ್ತದೆ malloc () (https://youtu.be/jnlKRnoT1m0):

ಪ್ರೋಗ್ರಾಂ ಹಲವಾರು ಕೆಲಸಗಳನ್ನು ಮಾಡುತ್ತದೆ. ಮೊದಲಿಗೆ, ಇದು ಕೆಲವು ಮೆಮೊರಿಯನ್ನು (ಲೈನ್ 7) ನಿಯೋಜಿಸುತ್ತದೆ, ನಂತರ ನಿಯೋಜಿಸಲಾದ ಸೆಲ್ (ಲೈನ್ 9) ವಿಳಾಸವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ, ಹಂಚಿಕೆ ಮೆಮೊರಿಯ ಮೊದಲ ಸ್ಲಾಟ್ಗೆ ಶೂನ್ಯವನ್ನು ಬರೆಯುತ್ತದೆ. ಮುಂದೆ, ಪ್ರೋಗ್ರಾಂ ಒಂದು ಲೂಪ್ ಅನ್ನು ಪ್ರವೇಶಿಸುತ್ತದೆ, ಇದರಲ್ಲಿ ಅದು ವೇರಿಯೇಬಲ್ "p" ನಲ್ಲಿನ ವಿಳಾಸದಲ್ಲಿ ಮೆಮೊರಿಯಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ಮೌಲ್ಯವನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ. ಇದು ಸ್ವತಃ ಪ್ರಕ್ರಿಯೆ ID ಯನ್ನು ಸಹ ಪ್ರದರ್ಶಿಸುತ್ತದೆ. ಪ್ರತಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಪ್ರಕ್ರಿಯೆಗೆ ಪ್ರಕ್ರಿಯೆ ID ಅನನ್ಯವಾಗಿದೆ. ಹಲವಾರು ಪ್ರತಿಗಳನ್ನು ಪ್ರಾರಂಭಿಸಿದ ನಂತರ, ನಾವು ಆಸಕ್ತಿದಾಯಕ ಫಲಿತಾಂಶವನ್ನು ಕಾಣುತ್ತೇವೆ: ಮೊದಲನೆಯ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಏನನ್ನೂ ಮಾಡದಿದ್ದರೆ ಮತ್ತು ಹಲವಾರು ಪ್ರತಿಗಳನ್ನು ಪ್ರಾರಂಭಿಸಿದರೆ, ವಿಳಾಸಗಳು ವಿಭಿನ್ನವಾಗಿರುತ್ತದೆ. ಆದರೆ ಇದು ನಮ್ಮ ಸಿದ್ಧಾಂತದ ಅಡಿಯಲ್ಲಿ ಬರುವುದಿಲ್ಲ! ನಿಜ, ಏಕೆಂದರೆ ಆಧುನಿಕ ವಿತರಣೆಗಳು ಡೀಫಾಲ್ಟ್ ಆಗಿ ಮೆಮೊರಿ ಯಾದೃಚ್ಛಿಕತೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತವೆ. ನೀವು ಅದನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಿದರೆ, ನಾವು ನಿರೀಕ್ಷಿತ ಫಲಿತಾಂಶವನ್ನು ಪಡೆಯುತ್ತೇವೆ - ಎರಡು ಏಕಕಾಲದಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಪ್ರೋಗ್ರಾಂಗಳ ಮೆಮೊರಿ ವಿಳಾಸಗಳು ಹೊಂದಿಕೆಯಾಗುತ್ತವೆ.

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

ಸ್ಥಿರತೆ

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

ಕೆಳಗಿನ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಪರಿಗಣಿಸಿ:

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

ಈ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು 1000 ವಾದದೊಂದಿಗೆ ರನ್ ಮಾಡೋಣ. ನೀವು ಊಹಿಸಿದಂತೆ, ಫಲಿತಾಂಶವು 2000 ಆಗಿರಬೇಕು, ಏಕೆಂದರೆ ಪ್ರತಿ ಥ್ರೆಡ್ ವೇರಿಯಬಲ್ ಅನ್ನು 1000 ಬಾರಿ ಹೆಚ್ಚಿಸಿದೆ. ಆದಾಗ್ಯೂ, ಎಲ್ಲವೂ ಅಷ್ಟು ಸುಲಭವಲ್ಲ. ಹೆಚ್ಚಿನ ಪುನರಾವರ್ತನೆಗಳ ಕ್ರಮದಲ್ಲಿ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಚಲಾಯಿಸಲು ಪ್ರಯತ್ನಿಸೋಣ.

ಸಂಖ್ಯೆಯನ್ನು ನಮೂದಿಸುವ ಮೂಲಕ, ಉದಾಹರಣೆಗೆ, 100000, ನಾವು ಔಟ್‌ಪುಟ್‌ನಲ್ಲಿ 200000 ಸಂಖ್ಯೆಯನ್ನು ನೋಡಲು ನಿರೀಕ್ಷಿಸುತ್ತೇವೆ. ಆದಾಗ್ಯೂ, 100000 ಸಂಖ್ಯೆಯನ್ನು ಹಲವಾರು ಬಾರಿ ಚಲಾಯಿಸುವ ಮೂಲಕ, ನಾವು ಸರಿಯಾದ ಉತ್ತರವನ್ನು ನೋಡುವುದಿಲ್ಲ, ಆದರೆ ವಿಭಿನ್ನ ತಪ್ಪು ಉತ್ತರಗಳನ್ನು ಸಹ ಸ್ವೀಕರಿಸುತ್ತೇವೆ. ಸಂಖ್ಯೆಯನ್ನು ಹೆಚ್ಚಿಸಲು ಮೂರು ಕಾರ್ಯಾಚರಣೆಗಳು ಬೇಕಾಗುತ್ತವೆ ಎಂಬ ಅಂಶದಲ್ಲಿ ಉತ್ತರವಿದೆ - ಮೆಮೊರಿಯಿಂದ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂಪಡೆಯುವುದು, ಅದನ್ನು ಹೆಚ್ಚಿಸುವುದು ಮತ್ತು ನಂತರ ಸಂಖ್ಯೆಯನ್ನು ಬರೆಯುವುದು. ಈ ಎಲ್ಲಾ ಸೂಚನೆಗಳನ್ನು ಪರಮಾಣುವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸದ ಕಾರಣ (ಎಲ್ಲವೂ ಒಂದೇ ಸಮಯದಲ್ಲಿ), ಈ ರೀತಿಯ ವಿಚಿತ್ರ ಸಂಗತಿಗಳು ಸಂಭವಿಸಬಹುದು. ಈ ಸಮಸ್ಯೆಯನ್ನು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ ಜನಾಂಗದ ಸ್ಥಿತಿ - ಜನಾಂಗದ ಸ್ಥಿತಿ. ಅಜ್ಞಾತ ಕ್ಷಣದಲ್ಲಿ ಅಜ್ಞಾತ ಶಕ್ತಿಗಳು ನಿಮ್ಮ ಯಾವುದೇ ಕಾರ್ಯಾಚರಣೆಗಳ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರಬಹುದು.

ಮೂಲ: www.habr.com