ಇತ್ತೀಚೆಗೆ Linux ಕರ್ನಲ್‌ಗಾಗಿ ಪ್ರಸ್ತಾವನೆಯನ್ನು ಬಿಡುಗಡೆ ಮಾಡಲಾಯಿತು, ಇದರಲ್ಲಿ ಒಂದು ಪ್ಯಾಚ್‌ಗಳ ಗುಂಪನ್ನು ಸೇರಿಸಲು ಪ್ರಸ್ತಾಪಿಸಲಾಗಿದೆ memchr() ಕಾರ್ಯದ ಆಪ್ಟಿಮೈಸ್ಡ್ ಅನುಷ್ಠಾನ ರಚನೆಯಲ್ಲಿನ ಪಾತ್ರವನ್ನು ಹುಡುಕಲು ಬಳಸಲಾಗುತ್ತದೆ.
memchr() ಕಾರ್ಯವು c ಯ ಮೊದಲ ನಿದರ್ಶನಕ್ಕಾಗಿ s ನಿಂದ ಸೂಚಿಸಲಾದ ಮೆಮೊರಿ ಪ್ರದೇಶದ ಪ್ರಮುಖ n ಬೈಟ್‌ಗಳನ್ನು ಸ್ಕ್ಯಾನ್ ಮಾಡುತ್ತದೆ. s ಮೂಲಕ ಸೂಚಿಸಲಾದ ಮೆಮೊರಿ ಪ್ರದೇಶದಲ್ಲಿನ c ಮತ್ತು ಬೈಟ್‌ಗಳನ್ನು ಸಹಿ ಮಾಡದ ಅಕ್ಷರಗಳಾಗಿ ಅರ್ಥೈಸಲಾಗುತ್ತದೆ.
ಪ್ರಸ್ತಾವನೆಯನ್ನು ಭರವಸೆ ವೇಗವಾಗಿರಿ ಮೆಮೊರಿಯ ಬ್ಲಾಕ್‌ನಲ್ಲಿ ಅಕ್ಷರವನ್ನು ಪತ್ತೆ ಮಾಡಲು. ಡೆವಲಪರ್ ಪರೀಕ್ಷೆಗಳಲ್ಲಿ, ದೊಡ್ಡ ಹುಡುಕಾಟಗಳಲ್ಲಿ ಹೊಸ ಅನುಷ್ಠಾನವು ಸುಮಾರು ನಾಲ್ಕು ಪಟ್ಟು ವೇಗವಾಗಿರುತ್ತದೆ
ಹಿಂದಿನ ಆವೃತ್ತಿಗಿಂತ ಭಿನ್ನವಾಗಿ, ಬೈಟ್-ಬೈ-ಬೈಟ್ ಹೋಲಿಕೆಯನ್ನು ಬಳಸಲಾಗಿದೆ, 64-ಬಿಟ್ ಮತ್ತು 32-ಬಿಟ್ CPU ರೆಜಿಸ್ಟರ್‌ಗಳ ಸಂಪೂರ್ಣ ಬಳಕೆಯನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಂಡು ಪ್ರಸ್ತಾವಿತ ಅನುಷ್ಠಾನವನ್ನು ರಚಿಸಲಾಗಿದೆ. ಬೈಟ್‌ಗಳ ಬದಲಿಗೆ, ಯಂತ್ರದ ಪದಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಹೋಲಿಕೆ ಮಾಡಲಾಗುತ್ತದೆ, ಇದು ಒಂದು ಸಮಯದಲ್ಲಿ ಕನಿಷ್ಠ 4 ಬೈಟ್‌ಗಳನ್ನು ಹೋಲಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
ಈ ಪ್ಯಾಚ್‌ಗಳ ಸರಣಿಯು "memchr()" ಅನ್ನು ಆಪ್ಟಿಮೈಸ್ ಮಾಡಲಾಗಿದೆ ಮತ್ತು ಇದಕ್ಕಾಗಿ ಮ್ಯಾಕ್ರೋವನ್ನು ಸೇರಿಸಲಾಗಿದೆ
"memchr_inv()" ಆದ್ದರಿಂದ ಎರಡೂ ಕಾರ್ಯಗಳು ಬಿಟ್‌ಮಾಸ್ಕ್ ಅನ್ನು ರಚಿಸಲು ಅದನ್ನು ಬಳಸಬಹುದು."memchr()" ನ ಮೂಲ ಅನುಷ್ಠಾನವು ಬೈಟ್ ಹೋಲಿಕೆಯನ್ನು ಆಧರಿಸಿದೆ,
ಇದು CPU ನಲ್ಲಿ 64 ಅಥವಾ 32 ಬಿಟ್ ರಿಜಿಸ್ಟರ್ ಅನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಬಳಸುವುದಿಲ್ಲ. ನಾವು ಎ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತೇವೆ
ಪದಗಳ ಮೂಲಕ ಹೋಲಿಕೆ ಮಾಡುವುದರಿಂದ ಕನಿಷ್ಠ 4 ಬೈಟ್‌ಗಳನ್ನು ಒಂದೇ ರೀತಿಯಲ್ಲಿ ಹೋಲಿಸಬಹುದು
ಹವಾಮಾನ. ಆಪ್ಟಿಮೈಸ್ ಮಾಡಿದ memchr() ಮೂಲಕ್ಕಿಂತ ಸುಮಾರು 4 ಪಟ್ಟು ವೇಗವಾಗಿದೆ
ದೀರ್ಘ ಸರಪಳಿಗಳಿಗಾಗಿ. ಲಿನಕ್ಸ್ ಕರ್ನಲ್‌ನಲ್ಲಿ, ಸ್ಟ್ರಿಂಗ್‌ನ ಉದ್ದವನ್ನು ನಾವು ಕಂಡುಕೊಳ್ಳುತ್ತೇವೆ
"memchr()" ಮೂಲಕ ಹುಡುಕಿದಾಗ ಡ್ರೈವರ್‌ಗಳು/misc/lkdtm/heap.c ನಲ್ಲಿ 512 ಬೈಟ್‌ಗಳವರೆಗೆ ಇರುತ್ತದೆ.
ದೊಡ್ಡ ತಂತಿಗಳಲ್ಲಿ ಹುಡುಕುವಾಗ, ಹೊಸ ಆವೃತ್ತಿಯು ಹಳೆಯದಕ್ಕಿಂತ ಸುಮಾರು 4 ಪಟ್ಟು ವೇಗವಾಗಿದೆ (ಉದಾಹರಣೆಗೆ, 1000 ಅಕ್ಷರಗಳ ತಂತಿಗಳಿಗೆ). ಸಣ್ಣ ಸರಪಳಿಗಳಿಗೆ, ಹೊಸ ಅನುಷ್ಠಾನದ ದಕ್ಷತೆಯು ಗಮನಾರ್ಹವಾಗಿಲ್ಲ, ಆದರೆ ಇದು ಮೂಲ ಆವೃತ್ತಿಗಿಂತ ಇನ್ನೂ ಹೆಚ್ಚಾಗಿರುತ್ತದೆ.
ಹೊಸ ಪ್ರಸ್ತಾಪದ ಬಗ್ಗೆ ಆಸಕ್ತಿದಾಯಕ ವಿಷಯವೆಂದರೆ ದೊಡ್ಡ ಸರಪಳಿಗಳ ಸುಧಾರಣೆಯಾಗಿದೆ, ಇದು ಸಮಯವನ್ನು ಗಣನೀಯವಾಗಿ ಸುಧಾರಿಸುತ್ತದೆ. ಲಿನಕ್ಸ್ ಕರ್ನಲ್‌ನಲ್ಲಿ ಇದನ್ನು ಉಲ್ಲೇಖಿಸುವುದು ಯೋಗ್ಯವಾಗಿದೆ, memchr () ನಲ್ಲಿ ಸಂಸ್ಕರಿಸಿದ ತಂತಿಗಳ ಗಾತ್ರವು 512 ಬೈಟ್‌ಗಳನ್ನು ತಲುಪುತ್ತದೆ. ನಮ್ಮ ಪರೀಕ್ಷೆಗಳಲ್ಲಿ, 512-ಬೈಟ್ ಸ್ಟ್ರಿಂಗ್‌ಗಳಿಗೆ ಕಾರ್ಯಕ್ಷಮತೆಯ ಗಳಿಕೆ, ಹುಡುಕಾಟ ಅಕ್ಷರದ ಪರಿಸ್ಥಿತಿಯಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್ ಕೊನೆಯಲ್ಲಿ, ಇದು 20% ಆಗಿದೆ.
64-ಬಿಟ್ ಅಥವಾ 32-ಬಿಟ್ CPU ನಲ್ಲಿ ರೆಜಿಸ್ಟರ್‌ಗಳನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಬಳಸದ ಬೈಟ್-ವೈಸ್ ಹೋಲಿಕೆ ತಂತ್ರದೊಂದಿಗೆ memchr () ನ ಮೂಲ ಆವೃತ್ತಿಯನ್ನು ಅಳವಡಿಸಲಾಗಿದೆ ಎಂದು ನಮೂದಿಸುವುದು ಯೋಗ್ಯವಾಗಿದೆ.
ನಾವು ಸಂಪೂರ್ಣ ಪದ ಹೋಲಿಕೆಯನ್ನು ಬಳಸುತ್ತೇವೆ ಇದರಿಂದ CPU ನಲ್ಲಿ ಒಂದೇ ಸಮಯದಲ್ಲಿ 8 ಅಕ್ಷರಗಳನ್ನು ಹೋಲಿಸಬಹುದು. ಈ ಕೋಡ್ ಡೇವಿಡ್ ಲೈಟ್‌ನ ಅನುಷ್ಠಾನವನ್ನು ಆಧರಿಸಿದೆ.
ಮೊದಲ ಫೈಲ್‌ನ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಅಳೆಯಲು ನಾವು ಎರಡು ಫೈಲ್‌ಗಳನ್ನು ರಚಿಸುತ್ತೇವೆ ಇದು ಗಮ್ಯಸ್ಥಾನದ ಅಕ್ಷರಕ್ಕಿಂತ ಸರಾಸರಿ 10 ಅಕ್ಷರಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಎರಡನೇ ಫೈಲ್ ಮೊದಲು ಕನಿಷ್ಠ 1000 ಅಕ್ಷರಗಳನ್ನು ಒಳಗೊಂಡಿದೆ ಗುರಿ ಪಾತ್ರ.
"memchr()" ನ ನಮ್ಮ ಅನುಷ್ಠಾನವು ಸ್ವಲ್ಪಮಟ್ಟಿಗೆ ಇದೆ ಮೊದಲ ಪರೀಕ್ಷೆಯಲ್ಲಿ ಉತ್ತಮ ಮತ್ತು ಮೂಲಕ್ಕಿಂತ ಸುಮಾರು 4 ಪಟ್ಟು ವೇಗವಾಗಿ ಎರಡನೇ ಪರೀಕ್ಷೆಯಲ್ಲಿ ಅನುಷ್ಠಾನ.
5.18-ಬಿಟ್ ಮತ್ತು 32-ಬಿಟ್ ಆರ್ಕಿಟೆಕ್ಚರ್‌ಗಳಿಗಾಗಿ ಹೊಸ "memchr()" ರೂಪಾಂತರದೊಂದಿಗೆ ಕರ್ನಲ್ 64 ಪರೀಕ್ಷೆ ಯಾವುದೇ ಸಮಸ್ಯೆಗಳನ್ನು ಬಹಿರಂಗಪಡಿಸಲಿಲ್ಲ.
p 8 (ಅಥವಾ 4 ಬಿಟ್ ಗುರಿಗಳಲ್ಲಿ 32) ಬೈಟ್ ಅನ್ನು ಜೋಡಿಸದಿದ್ದರೆ ಏನಾಗುತ್ತದೆ? ಎಲ್ಲಾ ಗುರಿಗಳು ಜೋಡಿಸದ (ಪರಿಣಾಮಕಾರಿ) ಲೋಡ್‌ಗಳನ್ನು ಬೆಂಬಲಿಸುವುದಿಲ್ಲ, ಸರಿ?
p 8 ಅಥವಾ 4 ಬೈಟ್ ಅನ್ನು ಜೋಡಿಸದಿದ್ದರೆ ಅದು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ. ಸ್ಟ್ರಿಂಗ್ 10 ಬೈಟ್‌ಗಳು ಎಂದು ಹೇಳೋಣ. ಇಲ್ಲಿ ಫಾರ್ ಲೂಪ್ ಮೊದಲ 8 ಬೈಟ್‌ಗಳನ್ನು ಹುಡುಕುತ್ತದೆ. ಗಮ್ಯಸ್ಥಾನದ ಅಕ್ಷರವು ಕೊನೆಯ 2 ಬೈಟ್‌ಗಳಲ್ಲಿದ್ದರೆ, ಲೂಪ್‌ಗಾಗಿ ಎರಡನೆಯದು ಅದನ್ನು ಕಂಡುಕೊಳ್ಳುತ್ತದೆ. ಇದು 32-ಬಿಟ್ ಯಂತ್ರಗಳಲ್ಲಿಯೂ ಈ ರೀತಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.
ಒಟ್ಟಾರೆ ಕಾರ್ಯಕ್ಷಮತೆಯ ಲಾಭವನ್ನು ಇನ್ನೂ ಮೌಲ್ಯಮಾಪನ ಮಾಡಲಾಗಿಲ್ಲ ಆಪ್ಟಿಮೈಸ್ಡ್ "memchr()" ರೂಪಾಂತರವನ್ನು ಬಳಸುವಾಗ ಕರ್ನಲ್ ಉಪವ್ಯವಸ್ಥೆಗಳು, ಅಥವಾ ಅನುಷ್ಠಾನವನ್ನು ಅತಿಕ್ರಮಿಸಬೇಕೆ ಎಂದು ಚರ್ಚಿಸಲಾಗಿಲ್ಲ (memchr() ಫಂಕ್ಷನ್ ಕರೆ ಕರ್ನಲ್ ಕೋಡ್‌ನಲ್ಲಿ ಡ್ರೈವರ್‌ಗಳು ಮತ್ತು ಫೈಲ್ ಸಿಸ್ಟಮ್‌ಗಳನ್ನು ಒಳಗೊಂಡಂತೆ 129 ಬಾರಿ ಸಂಭವಿಸುತ್ತದೆ).
ಅಂತಿಮವಾಗಿ ಇದರ ಬಗ್ಗೆ ಇನ್ನಷ್ಟು ತಿಳಿದುಕೊಳ್ಳಲು ನೀವು ಆಸಕ್ತಿ ಹೊಂದಿದ್ದರೆ, ನೀವು ವಿವರಗಳನ್ನು ಪರಿಶೀಲಿಸಬಹುದು ಕೆಳಗಿನ ಲಿಂಕ್‌ನಲ್ಲಿ.