ಕಂಪ್ಯೂಟರ್ ಸಿಸ್ಟಮ್ ಸಿಮ್ಯುಲೇಟರ್‌ಗಳ ಕುರಿತು ಲೇಖನದ ಎರಡನೇ ಭಾಗದಲ್ಲಿ, ನಾನು ಕಂಪ್ಯೂಟರ್ ಸಿಮ್ಯುಲೇಟರ್‌ಗಳ ಬಗ್ಗೆ ಸರಳ ಪರಿಚಯಾತ್ಮಕ ರೂಪದಲ್ಲಿ ಮಾತನಾಡುವುದನ್ನು ಮುಂದುವರಿಸುತ್ತೇನೆ, ಅವುಗಳೆಂದರೆ ಪೂರ್ಣ-ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಸಿಮ್ಯುಲೇಶನ್ ಬಗ್ಗೆ, ಇದು ಸರಾಸರಿ ಬಳಕೆದಾರರು ಹೆಚ್ಚಾಗಿ ಎದುರಿಸುತ್ತಾರೆ, ಜೊತೆಗೆ ಗಡಿಯಾರದ ಬಗ್ಗೆ - ಗಡಿಯಾರ ಮಾದರಿ ಮತ್ತು ಕುರುಹುಗಳು, ಇದು ಡೆವಲಪರ್ ವಲಯಗಳಲ್ಲಿ ಹೆಚ್ಚು ಸಾಮಾನ್ಯವಾಗಿದೆ.
В ನಾನು ಸಾಮಾನ್ಯವಾಗಿ ಸಿಮ್ಯುಲೇಟರ್‌ಗಳು ಯಾವುವು ಎಂಬುದರ ಕುರಿತು ಮತ್ತು ಸಿಮ್ಯುಲೇಶನ್ ಮಟ್ಟಗಳ ಬಗ್ಗೆ ಮಾತನಾಡಿದ್ದೇನೆ. ಈಗ, ಆ ಜ್ಞಾನದ ಆಧಾರದ ಮೇಲೆ, ನಾನು ಸ್ವಲ್ಪ ಆಳವಾಗಿ ಧುಮುಕುವುದು ಮತ್ತು ಪೂರ್ಣ-ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಸಿಮ್ಯುಲೇಶನ್ ಬಗ್ಗೆ ಮಾತನಾಡಲು ಪ್ರಸ್ತಾಪಿಸುತ್ತೇನೆ, ಕುರುಹುಗಳನ್ನು ಹೇಗೆ ಸಂಗ್ರಹಿಸುವುದು, ನಂತರ ಅವುಗಳನ್ನು ಏನು ಮಾಡಬೇಕು, ಹಾಗೆಯೇ ಗಡಿಯಾರದಿಂದ ಗಡಿಯಾರದ ಮೈಕ್ರೊಆರ್ಕಿಟೆಕ್ಚರಲ್ ಎಮ್ಯುಲೇಶನ್ ಬಗ್ಗೆ.
ಪೂರ್ಣ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಸಿಮ್ಯುಲೇಟರ್, ಅಥವಾ "ಕ್ಷೇತ್ರದಲ್ಲಿ ಒಬ್ಬನೇ ಯೋಧನಲ್ಲ"
ನೀವು ಒಂದು ನಿರ್ದಿಷ್ಟ ಸಾಧನದ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಅಧ್ಯಯನ ಮಾಡಲು ಬಯಸಿದರೆ, ಉದಾಹರಣೆಗೆ, ನೆಟ್ವರ್ಕ್ ಕಾರ್ಡ್, ಅಥವಾ ಈ ಸಾಧನಕ್ಕಾಗಿ ಫರ್ಮ್ವೇರ್ ಅಥವಾ ಡ್ರೈವರ್ ಅನ್ನು ಬರೆಯಿರಿ, ನಂತರ ಅಂತಹ ಸಾಧನವನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಅನುಕರಿಸಬಹುದು. ಆದಾಗ್ಯೂ, ಉಳಿದ ಮೂಲಸೌಕರ್ಯಗಳಿಂದ ಪ್ರತ್ಯೇಕವಾಗಿ ಬಳಸುವುದು ತುಂಬಾ ಅನುಕೂಲಕರವಲ್ಲ. ಅನುಗುಣವಾದ ಚಾಲಕವನ್ನು ಚಲಾಯಿಸಲು, ನಿಮಗೆ ಸೆಂಟ್ರಲ್ ಪ್ರೊಸೆಸರ್, ಮೆಮೊರಿ, ಡೇಟಾ ಬಸ್ಗೆ ಪ್ರವೇಶ, ಇತ್ಯಾದಿಗಳ ಅಗತ್ಯವಿರುತ್ತದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಚಾಲಕವು ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ (OS) ಮತ್ತು ನೆಟ್ವರ್ಕ್ ಸ್ಟಾಕ್ ಅಗತ್ಯವಿರುತ್ತದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಪ್ರತ್ಯೇಕ ಪ್ಯಾಕೆಟ್ ಜನರೇಟರ್ ಮತ್ತು ಪ್ರತಿಕ್ರಿಯೆ ಸರ್ವರ್ ಅಗತ್ಯವಿರಬಹುದು.
ಪೂರ್ಣ-ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಸಿಮ್ಯುಲೇಟರ್ ಸಂಪೂರ್ಣ ಸಾಫ್ಟ್ವೇರ್ ಸ್ಟ್ಯಾಕ್ ಅನ್ನು ಚಲಾಯಿಸಲು ಪರಿಸರವನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ, ಇದು BIOS ಮತ್ತು ಬೂಟ್‌ಲೋಡರ್‌ನಿಂದ OS ಮತ್ತು ಅದರ ವಿವಿಧ ಉಪವ್ಯವಸ್ಥೆಗಳಾದ ಅದೇ ನೆಟ್ವರ್ಕ್ ಸ್ಟಾಕ್, ಡ್ರೈವರ್‌ಗಳು ಮತ್ತು ಬಳಕೆದಾರ-ಮಟ್ಟದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಂತಹ ಎಲ್ಲವನ್ನೂ ಒಳಗೊಂಡಿರುತ್ತದೆ. ಇದನ್ನು ಮಾಡಲು, ಇದು ಹೆಚ್ಚಿನ ಕಂಪ್ಯೂಟರ್ ಸಾಧನಗಳ ಸಾಫ್ಟ್ವೇರ್ ಮಾದರಿಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ: ಪ್ರೊಸೆಸರ್ ಮತ್ತು ಮೆಮೊರಿ, ಡಿಸ್ಕ್, ಇನ್ಪುಟ್/ಔಟ್ಪುಟ್ ಸಾಧನಗಳು (ಕೀಬೋರ್ಡ್, ಮೌಸ್, ಡಿಸ್ಪ್ಲೇ), ಹಾಗೆಯೇ ಅದೇ ನೆಟ್ವರ್ಕ್ ಕಾರ್ಡ್.
ಇಂಟೆಲ್‌ನಿಂದ x58 ಚಿಪ್‌ಸೆಟ್‌ನ ಬ್ಲಾಕ್ ರೇಖಾಚಿತ್ರವನ್ನು ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ. ಈ ಚಿಪ್‌ಸೆಟ್‌ನಲ್ಲಿರುವ ಪೂರ್ಣ-ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಕಂಪ್ಯೂಟರ್ ಸಿಮ್ಯುಲೇಟರ್‌ಗೆ IOH (ಇನ್ಪುಟ್/ಔಟ್ಪುಟ್ ಹಬ್) ಮತ್ತು ICH (ಇನ್ಪುಟ್/ಔಟ್ಪುಟ್ ಕಂಟ್ರೋಲರ್ ಹಬ್) ಒಳಗಿರುವಂತಹ ಪಟ್ಟಿ ಮಾಡಲಾದ ಹೆಚ್ಚಿನ ಸಾಧನಗಳ ಅನುಷ್ಠಾನದ ಅಗತ್ಯವಿದೆ, ಇವುಗಳನ್ನು ಬ್ಲಾಕ್ ರೇಖಾಚಿತ್ರದಲ್ಲಿ ವಿವರವಾಗಿ ಚಿತ್ರಿಸಲಾಗಿಲ್ಲ. . ಆದಾಗ್ಯೂ, ಅಭ್ಯಾಸ ಪ್ರದರ್ಶನಗಳಂತೆ, ನಾವು ಚಲಾಯಿಸಲಿರುವ ಸಾಫ್ಟ್‌ವೇರ್‌ನಿಂದ ಬಳಸದ ಹೆಚ್ಚಿನ ಸಾಧನಗಳಿಲ್ಲ. ಅಂತಹ ಸಾಧನಗಳ ಮಾದರಿಗಳನ್ನು ರಚಿಸುವ ಅಗತ್ಯವಿಲ್ಲ.
ಹೆಚ್ಚಾಗಿ, ಪೂರ್ಣ-ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಸಿಮ್ಯುಲೇಟರ್‌ಗಳನ್ನು ಪ್ರೊಸೆಸರ್ ಸೂಚನಾ ಮಟ್ಟದಲ್ಲಿ ಅಳವಡಿಸಲಾಗಿದೆ (ISA, ಕೆಳಗೆ ನೋಡಿ). ) ತುಲನಾತ್ಮಕವಾಗಿ ತ್ವರಿತವಾಗಿ ಮತ್ತು ಅಗ್ಗವಾಗಿ ಸಿಮ್ಯುಲೇಟರ್ ಅನ್ನು ರಚಿಸಲು ಇದು ನಿಮ್ಮನ್ನು ಅನುಮತಿಸುತ್ತದೆ. ISA ಮಟ್ಟವು ಸಹ ಉತ್ತಮವಾಗಿದೆ ಏಕೆಂದರೆ ಇದು ಹೆಚ್ಚು ಅಥವಾ ಕಡಿಮೆ ಸ್ಥಿರವಾಗಿರುತ್ತದೆ, ಉದಾಹರಣೆಗೆ, API/ABI ಮಟ್ಟಕ್ಕಿಂತ ಭಿನ್ನವಾಗಿ, ಇದು ಹೆಚ್ಚಾಗಿ ಬದಲಾಗುತ್ತದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಸೂಚನಾ ಮಟ್ಟದಲ್ಲಿ ಅನುಷ್ಠಾನವು ಮಾರ್ಪಡಿಸದ ಬೈನರಿ ಸಾಫ್ಟ್ವೇರ್ ಎಂದು ಕರೆಯಲ್ಪಡುವದನ್ನು ಚಲಾಯಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಅಂದರೆ, ನೈಜ ಹಾರ್ಡ್‌ವೇರ್‌ನಲ್ಲಿ ಬಳಸಿದಂತೆ ಯಾವುದೇ ಬದಲಾವಣೆಗಳಿಲ್ಲದೆ ಈಗಾಗಲೇ ಕಂಪೈಲ್ ಮಾಡಿದ ಕೋಡ್ ಅನ್ನು ಚಲಾಯಿಸಿ. ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ನಿಮ್ಮ ಹಾರ್ಡ್ ಡ್ರೈವ್‌ನ ನಕಲು ("ಡಂಪ್") ಅನ್ನು ನೀವು ಮಾಡಬಹುದು, ಪೂರ್ಣ-ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಸಿಮ್ಯುಲೇಟರ್‌ನಲ್ಲಿನ ಮಾದರಿಯ ಚಿತ್ರವಾಗಿ ಅದನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿ ಮತ್ತು ವೊಯ್ಲಾ! - ಯಾವುದೇ ಹೆಚ್ಚುವರಿ ಕ್ರಿಯೆಗಳಿಲ್ಲದೆ OS ಮತ್ತು ಇತರ ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ಸಿಮ್ಯುಲೇಟರ್‌ನಲ್ಲಿ ಲೋಡ್ ಮಾಡಲಾಗುತ್ತದೆ.
ಸಿಮ್ಯುಲೇಟರ್ ಕಾರ್ಯಕ್ಷಮತೆ
ಮೇಲೆ ಹೇಳಿದಂತೆ, ಸಂಪೂರ್ಣ ವ್ಯವಸ್ಥೆಯನ್ನು ಅನುಕರಿಸುವ ಪ್ರಕ್ರಿಯೆ, ಅಂದರೆ, ಅದರ ಎಲ್ಲಾ ಸಾಧನಗಳು, ನಿಧಾನಗತಿಯ ಕಾರ್ಯವಾಗಿದೆ. ನೀವು ಇದನ್ನೆಲ್ಲ ಬಹಳ ವಿವರವಾದ ಮಟ್ಟದಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಿದರೆ, ಉದಾಹರಣೆಗೆ, ಮೈಕ್ರೊ ಆರ್ಕಿಟೆಕ್ಚರಲ್ ಅಥವಾ ತಾರ್ಕಿಕ, ನಂತರ ಮರಣದಂಡನೆ ತುಂಬಾ ನಿಧಾನವಾಗುತ್ತದೆ. ಆದರೆ ಸೂಚನಾ ಮಟ್ಟವು ಸೂಕ್ತವಾದ ಆಯ್ಕೆಯಾಗಿದೆ ಮತ್ತು OS ಮತ್ತು ಪ್ರೋಗ್ರಾಂಗಳು ಬಳಕೆದಾರರೊಂದಿಗೆ ಆರಾಮವಾಗಿ ಸಂವಹನ ನಡೆಸಲು ಸಾಕಷ್ಟು ವೇಗದಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಅನುಮತಿಸುತ್ತದೆ.
ಇಲ್ಲಿ ಸಿಮ್ಯುಲೇಟರ್ ಕಾರ್ಯಕ್ಷಮತೆಯ ವಿಷಯದ ಮೇಲೆ ಸ್ಪರ್ಶಿಸುವುದು ಸೂಕ್ತವಾಗಿದೆ. ಇದನ್ನು ಸಾಮಾನ್ಯವಾಗಿ IPS (ಪ್ರತಿ ಸೆಕೆಂಡಿಗೆ ಸೂಚನೆಗಳು), ಹೆಚ್ಚು ನಿಖರವಾಗಿ MIPS (ಮಿಲಿಯನ್ IPS) ನಲ್ಲಿ ಅಳೆಯಲಾಗುತ್ತದೆ, ಅಂದರೆ, ಒಂದು ಸೆಕೆಂಡಿನಲ್ಲಿ ಸಿಮ್ಯುಲೇಟರ್‌ನಿಂದ ಕಾರ್ಯಗತಗೊಳಿಸಿದ ಪ್ರೊಸೆಸರ್ ಸೂಚನೆಗಳ ಸಂಖ್ಯೆ. ಅದೇ ಸಮಯದಲ್ಲಿ, ಸಿಮ್ಯುಲೇಶನ್‌ನ ವೇಗವು ಸಿಮ್ಯುಲೇಶನ್ ಸ್ವತಃ ಚಲಿಸುವ ವ್ಯವಸ್ಥೆಯ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ಆದ್ದರಿಂದ, ಮೂಲ ವ್ಯವಸ್ಥೆಗೆ ಹೋಲಿಸಿದರೆ ಸಿಮ್ಯುಲೇಟರ್ನ "ನಿಧಾನ" ದ ಬಗ್ಗೆ ಮಾತನಾಡಲು ಇದು ಹೆಚ್ಚು ಸರಿಯಾಗಿರಬಹುದು.
QEMU, VirtualBox ಅಥವಾ VmWare ವರ್ಕ್‌ಸ್ಟೇಷನ್‌ನಂತಹ ಮಾರುಕಟ್ಟೆಯಲ್ಲಿ ಅತ್ಯಂತ ಸಾಮಾನ್ಯವಾದ ಪೂರ್ಣ-ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಸಿಮ್ಯುಲೇಟರ್‌ಗಳು ಉತ್ತಮ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಹೊಂದಿವೆ. ಸಿಮ್ಯುಲೇಟರ್‌ನಲ್ಲಿ ಕೆಲಸ ನಡೆಯುತ್ತಿದೆ ಎಂದು ಬಳಕೆದಾರರಿಗೆ ಗಮನಿಸದೇ ಇರಬಹುದು. ಪ್ರೊಸೆಸರ್‌ಗಳು, ಬೈನರಿ ಅನುವಾದ ಅಲ್ಗಾರಿದಮ್‌ಗಳು ಮತ್ತು ಇತರ ಆಸಕ್ತಿದಾಯಕ ವಿಷಯಗಳಲ್ಲಿ ಅಳವಡಿಸಲಾಗಿರುವ ವಿಶೇಷ ವರ್ಚುವಲೈಸೇಶನ್ ಸಾಮರ್ಥ್ಯಗಳಿಗೆ ಇದು ಧನ್ಯವಾದಗಳು. ಇದೆಲ್ಲವೂ ಪ್ರತ್ಯೇಕ ಲೇಖನಕ್ಕಾಗಿ ಒಂದು ವಿಷಯವಾಗಿದೆ, ಆದರೆ ಸಂಕ್ಷಿಪ್ತವಾಗಿ, ವರ್ಚುವಲೈಸೇಶನ್ ಆಧುನಿಕ ಪ್ರೊಸೆಸರ್‌ಗಳ ಹಾರ್ಡ್‌ವೇರ್ ವೈಶಿಷ್ಟ್ಯವಾಗಿದೆ, ಇದು ಸಿಮ್ಯುಲೇಟರ್‌ಗಳಿಗೆ ಸೂಚನೆಗಳನ್ನು ಅನುಕರಿಸಲು ಅನುಮತಿಸುವುದಿಲ್ಲ, ಆದರೆ ಅವುಗಳನ್ನು ನೇರವಾಗಿ ನೈಜ ಪ್ರೊಸೆಸರ್‌ಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಕಳುಹಿಸಲು, ಸಹಜವಾಗಿ, ಆರ್ಕಿಟೆಕ್ಚರ್‌ಗಳು ಸಿಮ್ಯುಲೇಟರ್ ಮತ್ತು ಪ್ರೊಸೆಸರ್ ಒಂದೇ ಆಗಿರುತ್ತವೆ. ಬೈನರಿ ಅನುವಾದವು ಅತಿಥಿ ಯಂತ್ರದ ಕೋಡ್ ಅನ್ನು ಹೋಸ್ಟ್ ಕೋಡ್‌ಗೆ ಅನುವಾದಿಸುತ್ತದೆ ಮತ್ತು ನಿಜವಾದ ಪ್ರೊಸೆಸರ್ನಲ್ಲಿ ನಂತರದ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯಾಗಿದೆ. ಪರಿಣಾಮವಾಗಿ, ಸಿಮ್ಯುಲೇಶನ್ ಸ್ವಲ್ಪ ನಿಧಾನವಾಗಿರುತ್ತದೆ, 5-10 ಬಾರಿ, ಮತ್ತು ಆಗಾಗ್ಗೆ ನೈಜ ಸಿಸ್ಟಮ್‌ನಂತೆಯೇ ಅದೇ ವೇಗದಲ್ಲಿ ಚಲಿಸುತ್ತದೆ. ಇದು ಅನೇಕ ಅಂಶಗಳಿಂದ ಪ್ರಭಾವಿತವಾಗಿದ್ದರೂ ಸಹ. ಉದಾಹರಣೆಗೆ, ನಾವು ಹಲವಾರು ಡಜನ್ ಪ್ರೊಸೆಸರ್‌ಗಳೊಂದಿಗೆ ಸಿಸ್ಟಮ್ ಅನ್ನು ಅನುಕರಿಸಲು ಬಯಸಿದರೆ, ವೇಗವು ತಕ್ಷಣವೇ ಈ ಹಲವಾರು ಡಜನ್ ಬಾರಿ ಇಳಿಯುತ್ತದೆ. ಮತ್ತೊಂದೆಡೆ, ಇತ್ತೀಚಿನ ಆವೃತ್ತಿಗಳಲ್ಲಿ ಸಿಮಿಕ್ಸ್‌ನಂತಹ ಸಿಮ್ಯುಲೇಟರ್‌ಗಳು ಮಲ್ಟಿಪ್ರೊಸೆಸರ್ ಹೋಸ್ಟ್ ಹಾರ್ಡ್‌ವೇರ್ ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ ಮತ್ತು ನೈಜ ಪ್ರೊಸೆಸರ್ನ ಕೋರ್‌ಗಳಿಗೆ ಸಿಮ್ಯುಲೇಟೆಡ್ ಕೋರ್‌ಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಸಮಾನಾಂತರಗೊಳಿಸುತ್ತದೆ.
ನಾವು ಮೈಕ್ರೊ ಆರ್ಕಿಟೆಕ್ಚರಲ್ ಸಿಮ್ಯುಲೇಶನ್‌ನ ವೇಗದ ಬಗ್ಗೆ ಮಾತನಾಡಿದರೆ, ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಹಲವಾರು ಆದೇಶಗಳ ಪ್ರಮಾಣವಾಗಿದೆ, ಸಿಮ್ಯುಲೇಶನ್ ಇಲ್ಲದೆ ಸಾಮಾನ್ಯ ಕಂಪ್ಯೂಟರ್‌ನಲ್ಲಿ ಮರಣದಂಡನೆಗಿಂತ ಸುಮಾರು 1000-10000 ಪಟ್ಟು ನಿಧಾನವಾಗಿರುತ್ತದೆ. ಮತ್ತು ತಾರ್ಕಿಕ ಅಂಶಗಳ ಮಟ್ಟದಲ್ಲಿ ಅಳವಡಿಕೆಗಳು ಪರಿಮಾಣದ ಹಲವಾರು ಕ್ರಮಗಳಿಂದ ನಿಧಾನವಾಗಿರುತ್ತವೆ. ಆದ್ದರಿಂದ, FPGA ಅನ್ನು ಈ ಮಟ್ಟದಲ್ಲಿ ಎಮ್ಯುಲೇಟರ್ ಆಗಿ ಬಳಸಲಾಗುತ್ತದೆ, ಇದು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಹೆಚ್ಚಿಸುತ್ತದೆ.
ಕೆಳಗಿನ ಗ್ರಾಫ್ ಮಾದರಿಯ ವಿವರಗಳ ಮೇಲೆ ಸಿಮ್ಯುಲೇಶನ್ ವೇಗದ ಅಂದಾಜು ಅವಲಂಬನೆಯನ್ನು ತೋರಿಸುತ್ತದೆ.
ಬೀಟ್-ಬೈ-ಬೀಟ್ ಸಿಮ್ಯುಲೇಶನ್
ಅವುಗಳ ಕಡಿಮೆ ಮರಣದಂಡನೆಯ ವೇಗದ ಹೊರತಾಗಿಯೂ, ಮೈಕ್ರೊ ಆರ್ಕಿಟೆಕ್ಚರಲ್ ಸಿಮ್ಯುಲೇಟರ್‌ಗಳು ಸಾಕಷ್ಟು ಸಾಮಾನ್ಯವಾಗಿದೆ. ಪ್ರತಿ ಸೂಚನೆಯ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಮಯವನ್ನು ನಿಖರವಾಗಿ ಅನುಕರಿಸಲು ಪ್ರೊಸೆಸರ್ನ ಆಂತರಿಕ ಬ್ಲಾಕ್ಗಳ ಸಿಮ್ಯುಲೇಶನ್ ಅವಶ್ಯಕವಾಗಿದೆ. ಇಲ್ಲಿ ತಪ್ಪು ತಿಳುವಳಿಕೆ ಉಂಟಾಗಬಹುದು - ಎಲ್ಲಾ ನಂತರ, ಪ್ರತಿ ಸೂಚನೆಗೆ ಮರಣದಂಡನೆ ಸಮಯವನ್ನು ಏಕೆ ಸರಳವಾಗಿ ಪ್ರೋಗ್ರಾಂ ಮಾಡಬಾರದು ಎಂದು ತೋರುತ್ತದೆ. ಆದರೆ ಅಂತಹ ಸಿಮ್ಯುಲೇಟರ್ ತುಂಬಾ ನಿಖರವಾಗಿಲ್ಲ, ಏಕೆಂದರೆ ಅದೇ ಸೂಚನೆಯ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಮಯವು ಕರೆಯಿಂದ ಕರೆಗೆ ಭಿನ್ನವಾಗಿರಬಹುದು.
ಸರಳ ಉದಾಹರಣೆಯೆಂದರೆ ಮೆಮೊರಿ ಪ್ರವೇಶ ಸೂಚನೆ. ವಿನಂತಿಸಿದ ಮೆಮೊರಿ ಸ್ಥಳವು ಸಂಗ್ರಹದಲ್ಲಿ ಲಭ್ಯವಿದ್ದರೆ, ನಂತರ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಸಮಯವು ಕಡಿಮೆ ಇರುತ್ತದೆ. ಈ ಮಾಹಿತಿಯು ಸಂಗ್ರಹದಲ್ಲಿ ಇಲ್ಲದಿದ್ದರೆ ("ಸಂಗ್ರಹ ಮಿಸ್"), ನಂತರ ಇದು ಸೂಚನೆಯ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಮಯವನ್ನು ಹೆಚ್ಚು ಹೆಚ್ಚಿಸುತ್ತದೆ. ಹೀಗಾಗಿ, ನಿಖರವಾದ ಸಿಮ್ಯುಲೇಶನ್‌ಗಾಗಿ ಸಂಗ್ರಹ ಮಾದರಿಯ ಅಗತ್ಯವಿದೆ. ಆದಾಗ್ಯೂ, ವಿಷಯವು ಸಂಗ್ರಹ ಮಾದರಿಗೆ ಸೀಮಿತವಾಗಿಲ್ಲ. ಸಂಗ್ರಹಣೆಯಲ್ಲಿ ಇಲ್ಲದಿರುವಾಗ ಮೆಮೊರಿಯಿಂದ ಡೇಟಾವನ್ನು ಹಿಂಪಡೆಯಲು ಪ್ರೊಸೆಸರ್ ಸರಳವಾಗಿ ಕಾಯುವುದಿಲ್ಲ. ಬದಲಾಗಿ, ಇದು ಮುಂದಿನ ಸೂಚನೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ, ಮೆಮೊರಿಯಿಂದ ಓದುವ ಫಲಿತಾಂಶವನ್ನು ಅವಲಂಬಿಸಿರದದನ್ನು ಆರಿಸಿಕೊಳ್ಳುತ್ತದೆ. ಇದು "ಔಟ್ ಆಫ್ ಆರ್ಡರ್" ಎಕ್ಸಿಕ್ಯೂಶನ್ (OOO, ಔಟ್ ಆಫ್ ಆರ್ಡರ್ ಎಕ್ಸಿಕ್ಯೂಶನ್) ಎಂದು ಕರೆಯಲ್ಪಡುತ್ತದೆ, ಇದು ಪ್ರೊಸೆಸರ್ ಐಡಲ್ ಸಮಯವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಅವಶ್ಯಕವಾಗಿದೆ. ಅನುಗುಣವಾದ ಪ್ರೊಸೆಸರ್ ಬ್ಲಾಕ್ಗಳನ್ನು ಮಾಡೆಲಿಂಗ್ ಸೂಚನೆಗಳ ಮರಣದಂಡನೆಯ ಸಮಯವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವಾಗ ಈ ಎಲ್ಲವನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಈ ಸೂಚನೆಗಳಲ್ಲಿ, ಮೆಮೊರಿಯಿಂದ ಓದುವ ಫಲಿತಾಂಶವನ್ನು ನಿರೀಕ್ಷಿಸುತ್ತಿರುವಾಗ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ, ಷರತ್ತುಬದ್ಧ ಜಂಪ್ ಕಾರ್ಯಾಚರಣೆ ಸಂಭವಿಸಬಹುದು. ಸ್ಥಿತಿಯ ಫಲಿತಾಂಶವು ಕ್ಷಣದಲ್ಲಿ ತಿಳಿದಿಲ್ಲದಿದ್ದರೆ, ಮತ್ತೆ ಪ್ರೊಸೆಸರ್ ಮರಣದಂಡನೆಯನ್ನು ನಿಲ್ಲಿಸುವುದಿಲ್ಲ, ಆದರೆ "ಊಹೆ" ಮಾಡುತ್ತದೆ, ಸೂಕ್ತವಾದ ಶಾಖೆಯನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ ಮತ್ತು ಪರಿವರ್ತನೆಯ ಹಂತದಿಂದ ಪೂರ್ವಭಾವಿಯಾಗಿ ಸೂಚನೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದನ್ನು ಮುಂದುವರಿಸುತ್ತದೆ. ಬ್ರಾಂಚ್ ಪ್ರಿಡಿಕ್ಟರ್ ಎಂದು ಕರೆಯಲ್ಪಡುವ ಇಂತಹ ಬ್ಲಾಕ್ ಅನ್ನು ಮೈಕ್ರೊ ಆರ್ಕಿಟೆಕ್ಚರಲ್ ಸಿಮ್ಯುಲೇಟರ್‌ನಲ್ಲಿಯೂ ಅಳವಡಿಸಬೇಕು.
ಕೆಳಗಿನ ಚಿತ್ರವು ಪ್ರೊಸೆಸರ್ನ ಮುಖ್ಯ ಬ್ಲಾಕ್ಗಳನ್ನು ತೋರಿಸುತ್ತದೆ, ಅದನ್ನು ತಿಳಿದುಕೊಳ್ಳುವುದು ಅನಿವಾರ್ಯವಲ್ಲ, ಮೈಕ್ರೋಆರ್ಕಿಟೆಕ್ಚರಲ್ ಅನುಷ್ಠಾನದ ಸಂಕೀರ್ಣತೆಯನ್ನು ತೋರಿಸಲು ಮಾತ್ರ ಇದನ್ನು ತೋರಿಸಲಾಗುತ್ತದೆ.
ನಿಜವಾದ ಪ್ರೊಸೆಸರ್ನಲ್ಲಿ ಈ ಎಲ್ಲಾ ಬ್ಲಾಕ್ಗಳ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ವಿಶೇಷ ಗಡಿಯಾರ ಸಂಕೇತಗಳಿಂದ ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡಲಾಗಿದೆ ಮತ್ತು ಮಾದರಿಯಲ್ಲಿ ಅದೇ ಸಂಭವಿಸುತ್ತದೆ. ಅಂತಹ ಮೈಕ್ರೋಆರ್ಕಿಟೆಕ್ಚರಲ್ ಸಿಮ್ಯುಲೇಟರ್ ಅನ್ನು ಸೈಕಲ್ ನಿಖರ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಇದರ ಮುಖ್ಯ ಉದ್ದೇಶವು ಪ್ರೊಸೆಸರ್ನ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ನಿಖರವಾಗಿ ಊಹಿಸುವುದು ಮತ್ತು/ಅಥವಾ ನಿರ್ದಿಷ್ಟ ಪ್ರೋಗ್ರಾಂನ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಮಯವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು, ಉದಾಹರಣೆಗೆ, ಮಾನದಂಡ. ಮೌಲ್ಯಗಳು ಅಗತ್ಯಕ್ಕಿಂತ ಕಡಿಮೆಯಿದ್ದರೆ, ಅಲ್ಗಾರಿದಮ್‌ಗಳು ಮತ್ತು ಪ್ರೊಸೆಸರ್ ಬ್ಲಾಕ್ಗಳನ್ನು ಮಾರ್ಪಡಿಸುವುದು ಅಥವಾ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಆಪ್ಟಿಮೈಸ್ ಮಾಡುವುದು ಅಗತ್ಯವಾಗಿರುತ್ತದೆ.
ಮೇಲೆ ತೋರಿಸಿರುವಂತೆ, ಗಡಿಯಾರದಿಂದ ಗಡಿಯಾರದ ಸಿಮ್ಯುಲೇಶನ್ ತುಂಬಾ ನಿಧಾನವಾಗಿರುತ್ತದೆ, ಆದ್ದರಿಂದ ಪ್ರೋಗ್ರಾಂನ ಕಾರ್ಯಾಚರಣೆಯ ಕೆಲವು ಕ್ಷಣಗಳನ್ನು ಅಧ್ಯಯನ ಮಾಡುವಾಗ ಮಾತ್ರ ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ, ಅಲ್ಲಿ ಪ್ರೋಗ್ರಾಂ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯ ನೈಜ ವೇಗವನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ಮತ್ತು ಸಾಧನದ ಭವಿಷ್ಯದ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡುವುದು ಅವಶ್ಯಕ ಮೂಲಮಾದರಿಯನ್ನು ಅನುಕರಿಸಲಾಗುತ್ತಿದೆ.
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಪ್ರೋಗ್ರಾಂನ ಉಳಿದ ಚಾಲನೆಯಲ್ಲಿರುವ ಸಮಯವನ್ನು ಅನುಕರಿಸಲು ಕ್ರಿಯಾತ್ಮಕ ಸಿಮ್ಯುಲೇಟರ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಈ ಬಳಕೆಯ ಸಂಯೋಜನೆಯು ವಾಸ್ತವದಲ್ಲಿ ಹೇಗೆ ಸಂಭವಿಸುತ್ತದೆ? ಮೊದಲಿಗೆ, ಕ್ರಿಯಾತ್ಮಕ ಸಿಮ್ಯುಲೇಟರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ, ಅದರ ಮೇಲೆ OS ಮತ್ತು ಅಧ್ಯಯನದ ಅಡಿಯಲ್ಲಿ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಚಲಾಯಿಸಲು ಅಗತ್ಯವಿರುವ ಎಲ್ಲವನ್ನೂ ಲೋಡ್ ಮಾಡಲಾಗುತ್ತದೆ. ಎಲ್ಲಾ ನಂತರ, ನಾವು OS ನಲ್ಲಿಯೇ ಆಸಕ್ತಿ ಹೊಂದಿಲ್ಲ, ಅಥವಾ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವ ಆರಂಭಿಕ ಹಂತಗಳಲ್ಲಿ, ಅದರ ಕಾನ್ಫಿಗರೇಶನ್, ಇತ್ಯಾದಿ. ಆದಾಗ್ಯೂ, ನಾವು ಈ ಭಾಗಗಳನ್ನು ಬಿಟ್ಟುಬಿಡಲು ಸಾಧ್ಯವಿಲ್ಲ ಮತ್ತು ತಕ್ಷಣವೇ ಮಧ್ಯದಿಂದ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಮುಂದುವರಿಯುತ್ತೇವೆ. ಆದ್ದರಿಂದ, ಈ ಎಲ್ಲಾ ಪ್ರಾಥಮಿಕ ಹಂತಗಳನ್ನು ಕ್ರಿಯಾತ್ಮಕ ಸಿಮ್ಯುಲೇಟರ್‌ನಲ್ಲಿ ನಡೆಸಲಾಗುತ್ತದೆ. ನಮಗೆ ಆಸಕ್ತಿಯ ಕ್ಷಣಕ್ಕೆ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದ ನಂತರ, ಎರಡು ಆಯ್ಕೆಗಳು ಸಾಧ್ಯ. ನೀವು ಮಾದರಿಯನ್ನು ಗಡಿಯಾರ-ಬೈ-ಸೈಕಲ್ ಮಾದರಿಯೊಂದಿಗೆ ಬದಲಾಯಿಸಬಹುದು ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಮುಂದುವರಿಸಬಹುದು. ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಕೋಡ್ ಅನ್ನು ಬಳಸುವ ಸಿಮ್ಯುಲೇಶನ್ ಮೋಡ್ (ಅಂದರೆ, ನಿಯಮಿತ ಕಂಪೈಲ್ ಮಾಡಿದ ಪ್ರೋಗ್ರಾಂ ಫೈಲ್‌ಗಳು) ಅನ್ನು ಎಕ್ಸಿಕ್ಯೂಶನ್ ಡ್ರೈವನ್ ಸಿಮ್ಯುಲೇಶನ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಇದು ಅತ್ಯಂತ ಸಾಮಾನ್ಯವಾದ ಸಿಮ್ಯುಲೇಶನ್ ಆಯ್ಕೆಯಾಗಿದೆ. ಮತ್ತೊಂದು ವಿಧಾನವೂ ಸಾಧ್ಯ - ಟ್ರೇಸ್ ಚಾಲಿತ ಸಿಮ್ಯುಲೇಶನ್.
ಟ್ರೇಸ್-ಆಧಾರಿತ ಸಿಮ್ಯುಲೇಶನ್
ಇದು ಎರಡು ಹಂತಗಳನ್ನು ಒಳಗೊಂಡಿದೆ. ಕ್ರಿಯಾತ್ಮಕ ಸಿಮ್ಯುಲೇಟರ್ ಅಥವಾ ನೈಜ ಸಿಸ್ಟಮ್ನಲ್ಲಿ, ಪ್ರೋಗ್ರಾಂ ಕ್ರಿಯೆಗಳ ಲಾಗ್ ಅನ್ನು ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಫೈಲ್ಗೆ ಬರೆಯಲಾಗುತ್ತದೆ. ಈ ಲಾಗ್ ಅನ್ನು ಟ್ರೇಸ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಏನನ್ನು ಪರಿಶೀಲಿಸಲಾಗುತ್ತಿದೆ ಎಂಬುದರ ಆಧಾರದ ಮೇಲೆ, ಟ್ರೇಸ್ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಸೂಚನೆಗಳು, ಮೆಮೊರಿ ವಿಳಾಸಗಳು, ಪೋರ್ಟ್ ಸಂಖ್ಯೆಗಳು ಮತ್ತು ಅಡಚಣೆ ಮಾಹಿತಿಯನ್ನು ಒಳಗೊಂಡಿರಬಹುದು.
ಗಡಿಯಾರದಿಂದ ಗಡಿಯಾರದ ಸಿಮ್ಯುಲೇಟರ್ ಜಾಡಿನ ಓದುವಾಗ ಮತ್ತು ಅದರಲ್ಲಿ ಬರೆಯಲಾದ ಎಲ್ಲಾ ಸೂಚನೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದಾಗ, ಜಾಡಿನ "ಪ್ಲೇ" ಮಾಡುವುದು ಮುಂದಿನ ಹಂತವಾಗಿದೆ. ಕೊನೆಯಲ್ಲಿ, ನಾವು ಪ್ರೋಗ್ರಾಂನ ಈ ತುಣುಕಿನ ಮರಣದಂಡನೆ ಸಮಯವನ್ನು ಪಡೆಯುತ್ತೇವೆ, ಹಾಗೆಯೇ ಈ ಪ್ರಕ್ರಿಯೆಯ ವಿವಿಧ ಗುಣಲಕ್ಷಣಗಳು, ಉದಾಹರಣೆಗೆ, ಸಂಗ್ರಹದಲ್ಲಿನ ಹಿಟ್ಗಳ ಶೇಕಡಾವಾರು.
ಕುರುಹುಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಪ್ರಮುಖ ಲಕ್ಷಣವೆಂದರೆ ಡಿಟರ್ಮಿನಿಸಂ, ಅಂದರೆ, ಮೇಲೆ ವಿವರಿಸಿದ ರೀತಿಯಲ್ಲಿ ಸಿಮ್ಯುಲೇಶನ್ ಅನ್ನು ಚಾಲನೆ ಮಾಡುವ ಮೂಲಕ, ನಾವು ಮತ್ತೆ ಮತ್ತೆ ಅದೇ ಕ್ರಮಗಳ ಅನುಕ್ರಮವನ್ನು ಪುನರುತ್ಪಾದಿಸುತ್ತೇವೆ. ಮಾದರಿ ನಿಯತಾಂಕಗಳನ್ನು (ಕ್ಯಾಶ್, ಬಫರ್ ಮತ್ತು ಕ್ಯೂ ಗಾತ್ರಗಳು) ಬದಲಾಯಿಸುವ ಮೂಲಕ ಮತ್ತು ವಿಭಿನ್ನ ಆಂತರಿಕ ಅಲ್ಗಾರಿದಮ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಅಥವಾ ಅವುಗಳನ್ನು ಟ್ಯೂನ್ ಮಾಡುವ ಮೂಲಕ, ನಿರ್ದಿಷ್ಟ ನಿಯತಾಂಕವು ಸಿಸ್ಟಮ್ ಕಾರ್ಯಕ್ಷಮತೆಯ ಮೇಲೆ ಹೇಗೆ ಪರಿಣಾಮ ಬೀರುತ್ತದೆ ಮತ್ತು ಯಾವ ಆಯ್ಕೆಯು ಉತ್ತಮ ಫಲಿತಾಂಶಗಳನ್ನು ನೀಡುತ್ತದೆ ಎಂಬುದನ್ನು ಅಧ್ಯಯನ ಮಾಡಲು ಇದು ಸಾಧ್ಯವಾಗಿಸುತ್ತದೆ. ನಿಜವಾದ ಹಾರ್ಡ್‌ವೇರ್ ಮೂಲಮಾದರಿಯನ್ನು ರಚಿಸುವ ಮೊದಲು ಮೂಲಮಾದರಿಯ ಸಾಧನದ ಮಾದರಿಯೊಂದಿಗೆ ಇದೆಲ್ಲವನ್ನೂ ಮಾಡಬಹುದು.
ಈ ವಿಧಾನದ ಸಂಕೀರ್ಣತೆಯು ಮೊದಲು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರನ್ ಮಾಡುವ ಮತ್ತು ಟ್ರೇಸ್ ಅನ್ನು ಸಂಗ್ರಹಿಸುವ ಅಗತ್ಯತೆಯಲ್ಲಿದೆ, ಜೊತೆಗೆ ಟ್ರೇಸ್ ಫೈಲ್ನ ದೊಡ್ಡ ಗಾತ್ರವನ್ನು ಹೊಂದಿದೆ. ಪ್ರಯೋಜನಗಳು ಸಾಧನದ ಭಾಗ ಅಥವಾ ಆಸಕ್ತಿಯ ವೇದಿಕೆಯನ್ನು ಮಾತ್ರ ಅನುಕರಿಸಲು ಸಾಕು ಎಂಬ ಅಂಶವನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ, ಆದರೆ ಮರಣದಂಡನೆಯ ಮೂಲಕ ಸಿಮ್ಯುಲೇಶನ್ ಸಾಮಾನ್ಯವಾಗಿ ಸಂಪೂರ್ಣ ಮಾದರಿಯ ಅಗತ್ಯವಿರುತ್ತದೆ.
ಆದ್ದರಿಂದ, ಈ ಲೇಖನದಲ್ಲಿ ನಾವು ಪೂರ್ಣ-ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಸಿಮ್ಯುಲೇಶನ್‌ನ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ನೋಡಿದ್ದೇವೆ, ವಿವಿಧ ಹಂತಗಳಲ್ಲಿ ಅನುಷ್ಠಾನಗಳ ವೇಗ, ಗಡಿಯಾರ-ಬೈ-ಸೈಕಲ್ ಸಿಮ್ಯುಲೇಶನ್ ಮತ್ತು ಕುರುಹುಗಳ ಬಗ್ಗೆ ಮಾತನಾಡಿದ್ದೇವೆ. ಮುಂದಿನ ಲೇಖನದಲ್ಲಿ ನಾನು ವೈಯಕ್ತಿಕ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಮತ್ತು ದೊಡ್ಡ ಕಂಪನಿಗಳಲ್ಲಿ ಅಭಿವೃದ್ಧಿಯ ದೃಷ್ಟಿಕೋನದಿಂದ ಸಿಮ್ಯುಲೇಟರ್‌ಗಳನ್ನು ಬಳಸುವ ಮುಖ್ಯ ಸನ್ನಿವೇಶಗಳನ್ನು ವಿವರಿಸುತ್ತೇನೆ.
ಮೂಲ: www.habr.com