ಜರ್ಮನ್ ವಿಶ್ವವಿದ್ಯಾಲಯಗಳ ಸಂಶೋಧಕರ ಗುಂಪು ಪುನರಾವರ್ತನೆ , ಈ ಸಮಯದಲ್ಲಿ 10-ಗಿಗಾಬಿಟ್ ಇಂಟೆಲ್ Ixgbe (X10xx) ನೆಟ್ವರ್ಕ್ ಕಾರ್ಡ್‌ಗಳಿಗಾಗಿ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಡ್ರೈವರ್‌ನ 5 ಆವೃತ್ತಿಗಳನ್ನು ವಿವಿಧ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ ಅಭಿವೃದ್ಧಿಪಡಿಸಲಾಯಿತು. ಚಾಲಕವು ಬಳಕೆದಾರರ ಜಾಗದಲ್ಲಿ ಚಲಿಸುತ್ತದೆ ಮತ್ತು C, Rust, Go, C#, Java, OCaml, Haskell, Swift, JavaScript ಮತ್ತು Python ನಲ್ಲಿ ಅಳವಡಿಸಲಾಗಿದೆ. ಕೋಡ್ ಬರೆಯುವಾಗ, ಪ್ರತಿ ಭಾಷೆಯ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಂಡು, ಸಾಧ್ಯವಾದಷ್ಟು ಉತ್ತಮ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸಾಧಿಸುವುದು ಮುಖ್ಯ ಗಮನವಾಗಿತ್ತು. ಎಲ್ಲಾ ಆಯ್ಕೆಗಳು ಕ್ರಿಯಾತ್ಮಕತೆಯಲ್ಲಿ ಒಂದೇ ಆಗಿರುತ್ತವೆ ಮತ್ತು ಸರಿಸುಮಾರು 1000 ಸಾಲುಗಳ ಕೋಡ್ ಅನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ. ಯೋಜನೆಯ ಬೆಳವಣಿಗೆಗಳು BSD ಪರವಾನಗಿ ಅಡಿಯಲ್ಲಿ.
ಡ್ರೈವರ್‌ನ ರಸ್ಟ್ ಆವೃತ್ತಿಯು ಸಿ ಭಾಷೆಯಲ್ಲಿನ ರೆಫರೆನ್ಸ್ ಡ್ರೈವರ್‌ಗೆ ಕಾರ್ಯಕ್ಷಮತೆಯಲ್ಲಿ ಬಹಳ ಹತ್ತಿರದಲ್ಲಿದೆ. 32 ಪ್ಯಾಕೆಟ್‌ಗಳ ಬ್ಲಾಕ್‌ಗಳನ್ನು ಏಕಕಾಲದಲ್ಲಿ ಕಳುಹಿಸುವುದರೊಂದಿಗೆ ಲೋಡ್ ಅಡಿಯಲ್ಲಿ, ರಸ್ಟ್ ಡ್ರೈವರ್ ಸ್ವಲ್ಪ ಹಿಂದೆ ಇತ್ತು, ಆದರೆ ಪ್ರತಿ ಬ್ಲಾಕ್‌ಗೆ 32 ಪ್ಯಾಕೆಟ್‌ಗಳಿಗಿಂತ ಹೆಚ್ಚಿನ ಪರೀಕ್ಷೆಗಳಲ್ಲಿ, ವೇಗವು ಪ್ರಾಯೋಗಿಕವಾಗಿ ಸಿ ಡ್ರೈವರ್‌ಗಿಂತ ಭಿನ್ನವಾಗಿರಲಿಲ್ಲ ಮತ್ತು 28 ಮಿಲಿಯನ್ ಪ್ರಕ್ರಿಯೆಯ ಮಟ್ಟದಲ್ಲಿ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಪ್ರದರ್ಶಿಸಿತು. Xeon CPU E3-1230 v2 3.3 GHz ನೊಂದಿಗೆ ಸರ್ವರ್‌ನಲ್ಲಿ ಪ್ರತಿ ಸೆಕೆಂಡಿಗೆ ಪ್ಯಾಕೆಟ್‌ಗಳು.
ಕಾರ್ಯಕ್ಷಮತೆಯ ದೃಷ್ಟಿಯಿಂದ ಮುಂದಿನ ಸ್ಥಾನವನ್ನು Go ಮತ್ತು C# ಭಾಷೆಗಳಲ್ಲಿ ಚಾಲಕರು ಆಕ್ರಮಿಸಿಕೊಂಡಿದ್ದಾರೆ, ಇದು ಸಾಕಷ್ಟು ನಿಕಟ ಫಲಿತಾಂಶಗಳನ್ನು ತೋರಿಸಿದೆ (Go ಚಾಲಕವು 16 ಪ್ಯಾಕೆಟ್‌ಗಳವರೆಗಿನ ಪರೀಕ್ಷೆಗಳಲ್ಲಿ ಜಯಗಳಿಸಿತು ಮತ್ತು 16 ಪ್ಯಾಕೆಟ್‌ಗಳಿಗಿಂತ ಹೆಚ್ಚಿನ ಪರೀಕ್ಷೆಗಳಲ್ಲಿ ಸ್ವಲ್ಪ ಕಳೆದುಕೊಳ್ಳಲು ಪ್ರಾರಂಭಿಸಿತು. ಒಂದು ಬ್ಲಾಕ್ನಲ್ಲಿ). ಪ್ರತಿ ಬ್ಲಾಕ್‌ಗೆ 256 ಪ್ಯಾಕೆಟ್‌ಗಳೊಂದಿಗೆ, C# ಡ್ರೈವರ್‌ನ ಗರಿಷ್ಠ ಕಾರ್ಯಕ್ಷಮತೆ ಪ್ರತಿ ಸೆಕೆಂಡಿಗೆ ಸರಿಸುಮಾರು 28 ಮಿಲಿಯನ್ ಪ್ಯಾಕೆಟ್‌ಗಳು, ಮತ್ತು ಗೋ ಡ್ರೈವರ್ ಪ್ರತಿ ಸೆಕೆಂಡಿಗೆ ಸರಿಸುಮಾರು 25 ಮಿಲಿಯನ್ ಪ್ಯಾಕೆಟ್‌ಗಳು.
ಮುಂದೆ, ಸಾಕಷ್ಟು ನಿಕಟ ಫಲಿತಾಂಶಗಳೊಂದಿಗೆ, ಚಾಲಕರು
Java, OCaml ಮತ್ತು Haskell, ಈ ಹಿಂದೆ ಪರಿಗಣಿಸಲಾದ ಆಯ್ಕೆಗಳಿಗಿಂತ ಈಗಾಗಲೇ ಗಮನಾರ್ಹವಾಗಿ ಹಿಂದುಳಿದಿವೆ ಮತ್ತು ಪ್ರತಿ ಸೆಕೆಂಡ್ ಬಾರ್‌ಗೆ 12 ಮಿಲಿಯನ್ ಪ್ಯಾಕೆಟ್‌ಗಳನ್ನು ಜಯಿಸಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ. ಸ್ವಿಫ್ಟ್ ಮತ್ತು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಡ್ರೈವರ್‌ಗಳು ಇನ್ನೂ ಹೆಚ್ಚಿನ ವಿಳಂಬವನ್ನು ತೋರಿಸಿದವು, ಪ್ರತಿ ಸೆಕೆಂಡಿಗೆ 5 ಮಿಲಿಯನ್ ಪ್ಯಾಕೆಟ್‌ಗಳ ಮಟ್ಟದಲ್ಲಿ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.
ಪ್ರತಿ ಸೆಕೆಂಡಿಗೆ 0.14 ಮಿಲಿಯನ್ ಪ್ಯಾಕೆಟ್‌ಗಳನ್ನು ಮಾತ್ರ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಸಾಧ್ಯವಾದ ಪೈಥಾನ್ ಡ್ರೈವರ್‌ನಿಂದ ಉನ್ನತ ಶ್ರೇಣಿಯನ್ನು ಪೂರ್ಣಗೊಳಿಸಲಾಗಿದೆ. ಪೈಥಾನ್ ಅನುಷ್ಠಾನವನ್ನು JIT ಇಲ್ಲದೆ ಮತ್ತು ನಿರ್ದಿಷ್ಟ ಆಪ್ಟಿಮೈಸೇಶನ್‌ಗಳಿಲ್ಲದೆ ಇಂಟರ್ಪ್ರಿಟರ್‌ಗಳ ವೇಗವನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಲು ಬಳಸಲಾಯಿತು (ಕೋಡ್ ಅನ್ನು CPython 3.7 ಬಳಸಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗಿದೆ ಮತ್ತು PyPy ನೊಂದಿಗೆ ಹೊಂದಿಕೆಯಾಗುವುದಿಲ್ಲ, ಆದರೆ ಡೇಟಾ ಸಂಗ್ರಹಣಾ ರಚನೆಗಳ ಆಪ್ಟಿಮೈಸೇಶನ್ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಮಾರು 10 ಪಟ್ಟು ಸುಧಾರಿಸುತ್ತದೆ ಎಂದು ಗಮನಿಸಲಾಗಿದೆ. )
ಹೆಚ್ಚುವರಿಯಾಗಿ, ಬಫರಿಂಗ್‌ನ ಪರಿಣಾಮಕಾರಿತ್ವ ಮತ್ತು ಕಸ ಸಂಗ್ರಾಹಕನ ಪ್ರಭಾವವನ್ನು ತೋರಿಸಲು ಲೇಟೆನ್ಸಿ ಪರೀಕ್ಷೆಗಳನ್ನು ನಡೆಸಲಾಯಿತು. ಪರೀಕ್ಷೆಯು ಪ್ರತಿ ಪ್ಯಾಕೆಟ್ ಅನ್ನು ಕಳುಹಿಸಿದ ನಿಖರವಾದ ಸಮಯಕ್ಕೆ ಹೋಲಿಸಿದರೆ ಚಾಲಕರಿಂದ ಫಾರ್ವರ್ಡ್ ಮಾಡಿದ ನಂತರ ಸುಪ್ತತೆಯನ್ನು ಅಳೆಯುತ್ತದೆ. ನಾಯಕರು ಇನ್ನೂ ಸಿ ಮತ್ತು ರಸ್ಟ್ ಡ್ರೈವರ್‌ಗಳಾಗಿದ್ದರು, ಇದರ ಫಲಿತಾಂಶಗಳು ಪ್ರತಿ ಸೆಕೆಂಡಿಗೆ 1 ಮಿಲಿಯನ್ ಪ್ಯಾಕೆಟ್‌ಗಳ ಹರಿವಿಗೆ ಪ್ರಾಯೋಗಿಕವಾಗಿ ಪ್ರತ್ಯೇಕಿಸಲಾಗಲಿಲ್ಲ (ಅಂದಾಜು 20 µs). ಗೋ ಚಾಲಕನು ಉತ್ತಮ ಪ್ರದರ್ಶನ ನೀಡಿದನು, ನಾಯಕರಿಗಿಂತ ಸ್ವಲ್ಪ ಹಿಂದೆ ಮತ್ತು 20 µs ಮಟ್ಟದಲ್ಲಿ ಉಳಿದಿದ್ದಾನೆ. C# ಚಾಲಕವು ಸರಿಸುಮಾರು 50 µs ವಿಳಂಬವನ್ನು ತೋರಿಸಿದೆ.
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮತ್ತು ಜಾವಾ ಡ್ರೈವರ್‌ಗಳಿಂದ ದೀರ್ಘವಾದ ವಿಳಂಬಗಳನ್ನು ತೋರಿಸಲಾಗಿದೆ (300 µs ಗಿಂತ ಹೆಚ್ಚಿನ ಲೇಟೆನ್ಸಿಗಳು).
ಸಿ ಗಿಂತ ಉನ್ನತ ಮಟ್ಟದ ಭಾಷೆಗಳಲ್ಲಿ ಡ್ರೈವರ್‌ಗಳು ಮತ್ತು ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಘಟಕಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವ ಸಾಧ್ಯತೆಯನ್ನು ನಿರ್ಣಯಿಸಲು ಅಧ್ಯಯನವನ್ನು ನಡೆಸಲಾಯಿತು. ಪ್ರಸ್ತುತ, ಲಿನಕ್ಸ್‌ನಲ್ಲಿನ 39 ರಲ್ಲಿ 40 ಮೆಮೊರಿ ಸಮಸ್ಯೆಗಳು ಡ್ರೈವರ್‌ಗಳಿಗೆ ಸಂಬಂಧಿಸಿವೆ, ಆದ್ದರಿಂದ ಹೆಚ್ಚು ಸುರಕ್ಷಿತ ಭಾಷೆಯನ್ನು ಬಳಸುವ ಮತ್ತು ಡ್ರೈವರ್‌ಗಳನ್ನು ಕರ್ನಲ್‌ನಿಂದ ಮತ್ತು ಬಳಕೆದಾರ ಜಾಗಕ್ಕೆ ಚಲಿಸುವ ಸಮಸ್ಯೆಗಳು ಮತ್ತು ತಯಾರಕರು ಈಗಾಗಲೇ ಈ ದಿಕ್ಕಿನಲ್ಲಿ ಸಕ್ರಿಯವಾಗಿ ಪ್ರಯೋಗ ಮಾಡುತ್ತಿದ್ದಾರೆ (ಉದಾಹರಣೆಗೆ, OS ಗಾಗಿ Google TCP ಸ್ಟಾಕ್ ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಿದೆ ಗೋ ಭಾಷೆಯಲ್ಲಿ, ಕ್ಲೌಡ್‌ಫ್ಲೇರ್ ಕಂಪನಿ ರಸ್ಟ್‌ನಲ್ಲಿ QUIC ಪ್ರೋಟೋಕಾಲ್‌ನ ಅನುಷ್ಠಾನ, ಆಪಲ್ ಮೊಬೈಲ್ ಸಾಧನಗಳಲ್ಲಿನ TCP ಸ್ಟಾಕ್ ಅನ್ನು ಬಳಕೆದಾರರ ಜಾಗಕ್ಕೆ ಸರಿಸಿದೆ).
ಕೆಲಸದ ಸಂದರ್ಭದಲ್ಲಿ, ಚಾಲಕ ಅಭಿವೃದ್ಧಿಗೆ ರಸ್ಟ್ ಭಾಷೆ ಅತ್ಯುತ್ತಮ ಅಭ್ಯರ್ಥಿ ಎಂದು ತೀರ್ಮಾನಿಸಲಾಯಿತು. ರಸ್ಟ್‌ನ ಸಾಮರ್ಥ್ಯಗಳು ಸಿ ಡ್ರೈವರ್‌ಗಳಿಗೆ ಹೋಲಿಸಿದರೆ ಸುಮಾರು 2% ರಿಂದ 10% ಕಾರ್ಯಕ್ಷಮತೆ ನಷ್ಟದ ವೆಚ್ಚದಲ್ಲಿ ಕಡಿಮೆ-ಹಂತದ ಮೆಮೊರಿ ನಿರ್ವಹಣೆಗೆ ಸಂಬಂಧಿಸಿದ ಸಮಸ್ಯೆಗಳನ್ನು ನಿವಾರಿಸುತ್ತದೆ. ಕಸ ಸಂಗ್ರಹಣೆಯಿಂದ ಉಂಟಾಗುವ ಉಪ-ಮಿಲಿಸೆಕೆಂಡ್ ಲೇಟೆನ್ಸಿ ಸ್ವೀಕಾರಾರ್ಹವಾಗಿರುವ ಸಂದರ್ಭಗಳಲ್ಲಿ ಸಿಸ್ಟಮ್ ಘಟಕಗಳನ್ನು ರಚಿಸಲು Go ಮತ್ತು C# ಅನ್ನು ಸೂಕ್ತವೆಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ.
ಮೂಲ: opennet.ru