ಆರಂಭಿಕ ಭಾಷಣ
ನಾನು ಈ ವರದಿಯನ್ನು ಮಾಸ್ಕೋದಲ್ಲಿ ಗೋಫರ್‌ಕಾನ್ ರಷ್ಯಾ 2019 ಸಮ್ಮೇಳನದಲ್ಲಿ ಇಂಗ್ಲಿಷ್‌ನಲ್ಲಿ ಮತ್ತು ನಿಜ್ನಿ ನವ್‌ಗೊರೊಡ್‌ನಲ್ಲಿ ನಡೆದ ಸಭೆಯಲ್ಲಿ ರಷ್ಯನ್ ಭಾಷೆಯಲ್ಲಿ ನೀಡಿದ್ದೇನೆ. ನಾವು ಬಿಟ್ಮ್ಯಾಪ್ ಸೂಚ್ಯಂಕದ ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತಿದ್ದೇವೆ - ಬಿ-ಟ್ರೀಗಿಂತ ಕಡಿಮೆ ಸಾಮಾನ್ಯವಾಗಿದೆ, ಆದರೆ ಕಡಿಮೆ ಆಸಕ್ತಿದಾಯಕವಲ್ಲ. ಹಂಚಿಕೆ ಸಮ್ಮೇಳನದಲ್ಲಿ ಇಂಗ್ಲಿಷ್‌ನಲ್ಲಿ ಭಾಷಣಗಳು ಮತ್ತು ರಷ್ಯನ್ ಭಾಷೆಯಲ್ಲಿ ಪಠ್ಯ ಪ್ರತಿಗಳು.
ಬಿಟ್ಮ್ಯಾಪ್ ಸೂಚ್ಯಂಕವು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಅದು ಉತ್ತಮವಾದಾಗ, ಇತರ ಸೂಚ್ಯಂಕಗಳಿಗಿಂತ ಕೆಟ್ಟದ್ದಾಗಿರುವಾಗ ಮತ್ತು ಯಾವ ಸಂದರ್ಭಗಳಲ್ಲಿ ಅದು ಅವುಗಳಿಗಿಂತ ಗಮನಾರ್ಹವಾಗಿ ವೇಗವಾಗಿರುತ್ತದೆ ಎಂದು ನಾವು ನೋಡುತ್ತೇವೆ; ಯಾವ ಜನಪ್ರಿಯ DBMS ಗಳು ಈಗಾಗಲೇ ಬಿಟ್ಮ್ಯಾಪ್ ಇಂಡೆಕ್ಸ್‌ಗಳನ್ನು ಹೊಂದಿವೆ ಎಂದು ನೋಡೋಣ; ಗೋದಲ್ಲಿ ನಮ್ಮದೇ ಆದದನ್ನು ಬರೆಯಲು ಪ್ರಯತ್ನಿಸೋಣ. ಮತ್ತು "ಡಿಸರ್ಟ್‌ಗಾಗಿ" ನಾವು ನಮ್ಮದೇ ಆದ ಸೂಪರ್-ಫಾಸ್ಟ್ ವಿಶೇಷ ಡೇಟಾಬೇಸ್ ರಚಿಸಲು ಸಿದ್ದವಾಗಿರುವ ಲೈಬ್ರರಿಗಳನ್ನು ಬಳಸುತ್ತೇವೆ.
ನನ್ನ ಕೆಲಸವು ನಿಮಗೆ ಉಪಯುಕ್ತ ಮತ್ತು ಆಸಕ್ತಿದಾಯಕವಾಗಿದೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ. ಹೋಗು!
ಪರಿಚಯ
ಎಲ್ಲರಿಗು ನಮಸ್ಖರ! ಸಂಜೆ ಆರು ಗಂಟೆ ಮತ್ತು ನಾವೆಲ್ಲರೂ ಸುಸ್ತಾಗಿದ್ದೇವೆ. ನೀರಸ ಡೇಟಾಬೇಸ್ ಸೂಚ್ಯಂಕ ಸಿದ್ಧಾಂತದ ಬಗ್ಗೆ ಮಾತನಾಡಲು ಉತ್ತಮ ಸಮಯ, ಸರಿ? ಚಿಂತಿಸಬೇಡಿ, ನಾನು ಇಲ್ಲಿ ಮತ್ತು ಅಲ್ಲಿ ಒಂದೆರಡು ಸಾಲುಗಳ ಮೂಲ ಕೋಡ್ ಅನ್ನು ಹೊಂದಿದ್ದೇನೆ. 🙂
ಎಲ್ಲಾ ಹಾಸ್ಯಗಳನ್ನು ಬದಿಗಿಟ್ಟು, ವರದಿಯು ಮಾಹಿತಿಯಿಂದ ತುಂಬಿದೆ ಮತ್ತು ನಮಗೆ ಹೆಚ್ಚು ಸಮಯವಿಲ್ಲ. ಆದ್ದರಿಂದ ಪ್ರಾರಂಭಿಸೋಣ.
ಇಂದು ನಾನು ಈ ಕೆಳಗಿನವುಗಳ ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತೇನೆ:
- ಸೂಚ್ಯಂಕಗಳು ಯಾವುವು;
- ಬಿಟ್ಮ್ಯಾಪ್ ಸೂಚ್ಯಂಕ ಎಂದರೇನು;
- ಅದನ್ನು ಎಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ ಮತ್ತು ಎಲ್ಲಿ ಬಳಸಲಾಗುವುದಿಲ್ಲ ಮತ್ತು ಏಕೆ;
- ಗೋದಲ್ಲಿ ಸರಳವಾದ ಅನುಷ್ಠಾನ ಮತ್ತು ಕಂಪೈಲರ್ನೊಂದಿಗೆ ಸ್ವಲ್ಪ ಹೋರಾಟ;
- ಗೋ ಅಸೆಂಬ್ಲರ್ನಲ್ಲಿ ಸ್ವಲ್ಪ ಕಡಿಮೆ ಸರಳ, ಆದರೆ ಹೆಚ್ಚು ಉತ್ಪಾದಕ ಅನುಷ್ಠಾನ;
- ಬಿಟ್ಮ್ಯಾಪ್ ಸೂಚ್ಯಂಕಗಳ "ಸಮಸ್ಯೆಗಳು";
- ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಅನುಷ್ಠಾನಗಳು.
ಹಾಗಾದರೆ ಸೂಚ್ಯಂಕಗಳು ಯಾವುವು?
ಸೂಚ್ಯಂಕವು ಪ್ರತ್ಯೇಕ ಡೇಟಾ ರಚನೆಯಾಗಿದ್ದು, ಮುಖ್ಯ ಡೇಟಾದ ಜೊತೆಗೆ ನಾವು ನಿರ್ವಹಿಸುತ್ತೇವೆ ಮತ್ತು ನವೀಕರಿಸುತ್ತೇವೆ. ಹುಡುಕಾಟವನ್ನು ವೇಗಗೊಳಿಸಲು ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಸೂಚ್ಯಂಕಗಳಿಲ್ಲದೆ, ಹುಡುಕಾಟವು ಡೇಟಾವನ್ನು ಸಂಪೂರ್ಣವಾಗಿ (ಪೂರ್ಣ ಸ್ಕ್ಯಾನ್ ಎಂದು ಕರೆಯಲಾಗುವ ಪ್ರಕ್ರಿಯೆ) ಮೂಲಕ ಹೋಗಬೇಕಾಗುತ್ತದೆ, ಮತ್ತು ಈ ಪ್ರಕ್ರಿಯೆಯು ರೇಖೀಯ ಕ್ರಮಾವಳಿಯ ಸಂಕೀರ್ಣತೆಯನ್ನು ಹೊಂದಿದೆ. ಆದರೆ ಡೇಟಾಬೇಸ್‌ಗಳು ಸಾಮಾನ್ಯವಾಗಿ ದೊಡ್ಡ ಪ್ರಮಾಣದ ಡೇಟಾವನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ ಮತ್ತು ರೇಖೀಯ ಸಂಕೀರ್ಣತೆಯು ತುಂಬಾ ನಿಧಾನವಾಗಿರುತ್ತದೆ. ತಾತ್ತ್ವಿಕವಾಗಿ, ನಾವು ಲಾಗರಿಥಮಿಕ್ ಅಥವಾ ಸ್ಥಿರವಾದ ಒಂದನ್ನು ಪಡೆಯುತ್ತೇವೆ.
ಇದು ಅತ್ಯಂತ ಸಂಕೀರ್ಣವಾದ ವಿಷಯವಾಗಿದೆ, ಸೂಕ್ಷ್ಮತೆಗಳು ಮತ್ತು ವ್ಯಾಪಾರ-ವಹಿವಾಟುಗಳಿಂದ ತುಂಬಿದೆ, ಆದರೆ ದಶಕಗಳ ಡೇಟಾಬೇಸ್ ಅಭಿವೃದ್ಧಿ ಮತ್ತು ಸಂಶೋಧನೆಗಳನ್ನು ನೋಡಿದ ನಂತರ, ಡೇಟಾಬೇಸ್ ಸೂಚಿಕೆಗಳನ್ನು ರಚಿಸಲು ವ್ಯಾಪಕವಾಗಿ ಬಳಸಿದ ಕೆಲವು ವಿಧಾನಗಳಿವೆ ಎಂದು ನಾನು ಹೇಳಲು ಸಿದ್ಧನಿದ್ದೇನೆ.
ಹುಡುಕಾಟದ ಜಾಗವನ್ನು ಕ್ರಮಾನುಗತವಾಗಿ ಕಡಿಮೆ ಮಾಡುವುದು, ಹುಡುಕಾಟ ಜಾಗವನ್ನು ಸಣ್ಣ ಭಾಗಗಳಾಗಿ ವಿಭಜಿಸುವುದು ಮೊದಲ ವಿಧಾನವಾಗಿದೆ.
ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ವಿವಿಧ ರೀತಿಯ ಮರಗಳನ್ನು ಬಳಸಿ ಇದನ್ನು ಮಾಡುತ್ತೇವೆ. ಒಂದು ಉದಾಹರಣೆ ನಿಮ್ಮ ಕ್ಲೋಸೆಟ್‌ನಲ್ಲಿರುವ ವಸ್ತುಗಳ ದೊಡ್ಡ ಬಾಕ್ಸ್ ಆಗಿದ್ದು ಅದು ವಿಭಿನ್ನ ವಿಷಯಗಳಾಗಿ ವಿಂಗಡಿಸಲಾದ ವಸ್ತುಗಳ ಸಣ್ಣ ಪೆಟ್ಟಿಗೆಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ನಿಮಗೆ ಸಾಮಗ್ರಿಗಳ ಅಗತ್ಯವಿದ್ದರೆ, "ಕುಕೀಸ್" ಎಂದು ಹೇಳುವ ಬದಲು "ಮೆಟೀರಿಯಲ್ಸ್" ಎಂದು ಹೇಳುವ ಪೆಟ್ಟಿಗೆಯಲ್ಲಿ ನೀವು ಅವುಗಳನ್ನು ಹುಡುಕಬಹುದು, ಸರಿ?
ಬಯಸಿದ ಅಂಶ ಅಥವಾ ಅಂಶಗಳ ಗುಂಪನ್ನು ತಕ್ಷಣವೇ ಆಯ್ಕೆ ಮಾಡುವುದು ಎರಡನೆಯ ವಿಧಾನವಾಗಿದೆ. ನಾವು ಇದನ್ನು ಹ್ಯಾಶ್ ಮ್ಯಾಪ್‌ಗಳು ಅಥವಾ ರಿವರ್ಸ್ ಇಂಡೆಕ್ಸ್‌ಗಳಲ್ಲಿ ಮಾಡುತ್ತೇವೆ. ಹ್ಯಾಶ್ ನಕ್ಷೆಗಳನ್ನು ಬಳಸುವುದು ಹಿಂದಿನ ಉದಾಹರಣೆಗೆ ಹೋಲುತ್ತದೆ, ಆದರೆ ಬಾಕ್ಸ್‌ಗಳ ಪೆಟ್ಟಿಗೆಯ ಬದಲಿಗೆ, ನಿಮ್ಮ ಕ್ಲೋಸೆಟ್‌ನಲ್ಲಿ ಅಂತಿಮ ಐಟಂಗಳ ಸಣ್ಣ ಪೆಟ್ಟಿಗೆಗಳ ಗುಂಪನ್ನು ನೀವು ಹೊಂದಿದ್ದೀರಿ.
ಮೂರನೇ ವಿಧಾನವೆಂದರೆ ಹುಡುಕಾಟದ ಅಗತ್ಯವನ್ನು ತೊಡೆದುಹಾಕುವುದು. ನಾವು ಇದನ್ನು ಬ್ಲೂಮ್ ಫಿಲ್ಟರ್‌ಗಳು ಅಥವಾ ಕೋಗಿಲೆ ಫಿಲ್ಟರ್‌ಗಳನ್ನು ಬಳಸಿ ಮಾಡುತ್ತೇವೆ. ಮೊದಲನೆಯವರು ತಕ್ಷಣವೇ ಉತ್ತರವನ್ನು ನೀಡುತ್ತಾರೆ, ಹುಡುಕಾಟದಿಂದ ನಿಮ್ಮನ್ನು ಉಳಿಸುತ್ತಾರೆ.
ಆಧುನಿಕ ಯಂತ್ರಾಂಶವು ನಮಗೆ ನೀಡುವ ಎಲ್ಲಾ ಶಕ್ತಿಯನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಬಳಸಿಕೊಳ್ಳುವುದು ಕೊನೆಯ ವಿಧಾನವಾಗಿದೆ. ಬಿಟ್ಮ್ಯಾಪ್ ಇಂಡೆಕ್ಸ್‌ಗಳಲ್ಲಿ ನಾವು ಮಾಡುತ್ತಿರುವುದು ಇದನ್ನೇ. ಹೌದು, ಅವುಗಳನ್ನು ಬಳಸುವಾಗ ನಾವು ಕೆಲವೊಮ್ಮೆ ಸಂಪೂರ್ಣ ಸೂಚ್ಯಂಕದ ಮೂಲಕ ಹೋಗಬೇಕಾಗುತ್ತದೆ, ಆದರೆ ನಾವು ಅದನ್ನು ಸೂಪರ್ ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಮಾಡುತ್ತೇವೆ.
ನಾನು ಹೇಳಿದಂತೆ, ಡೇಟಾಬೇಸ್ ಸೂಚ್ಯಂಕಗಳ ವಿಷಯವು ವಿಶಾಲವಾಗಿದೆ ಮತ್ತು ಹೊಂದಾಣಿಕೆಗಳಿಂದ ತುಂಬಿದೆ. ಇದರರ್ಥ ಕೆಲವೊಮ್ಮೆ ನಾವು ಒಂದೇ ಸಮಯದಲ್ಲಿ ಹಲವಾರು ವಿಧಾನಗಳನ್ನು ಬಳಸಬಹುದು: ನಾವು ಹುಡುಕಾಟವನ್ನು ಇನ್ನಷ್ಟು ವೇಗಗೊಳಿಸಬೇಕಾದರೆ ಅಥವಾ ನಾವು ಎಲ್ಲಾ ಸಂಭಾವ್ಯ ಹುಡುಕಾಟ ಪ್ರಕಾರಗಳನ್ನು ಒಳಗೊಳ್ಳಬೇಕಾದರೆ.
ಇಂದು ನಾನು ಇವುಗಳ ಕನಿಷ್ಠ ತಿಳಿದಿರುವ ವಿಧಾನದ ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತೇನೆ - ಬಿಟ್ಮ್ಯಾಪ್ ಸೂಚ್ಯಂಕಗಳು.
ಈ ವಿಷಯದ ಬಗ್ಗೆ ಮಾತನಾಡಲು ನಾನು ಯಾರು?
ನಾನು Badoo ನಲ್ಲಿ ಟೀಮ್ ಲೀಡ್ ಆಗಿ ಕೆಲಸ ಮಾಡುತ್ತೇನೆ (ಬಹುಶಃ ನೀವು ನಮ್ಮ ಇತರ ಉತ್ಪನ್ನವಾದ ಬಂಬಲ್ ಬಗ್ಗೆ ಹೆಚ್ಚು ಪರಿಚಿತರಾಗಿರಬಹುದು). ನಾವು ಈಗಾಗಲೇ ಪ್ರಪಂಚದಾದ್ಯಂತ 400 ಮಿಲಿಯನ್‌ಗಿಂತಲೂ ಹೆಚ್ಚು ಬಳಕೆದಾರರನ್ನು ಹೊಂದಿದ್ದೇವೆ ಮತ್ತು ಅವರಿಗೆ ಉತ್ತಮ ಹೊಂದಾಣಿಕೆಯನ್ನು ಆಯ್ಕೆ ಮಾಡುವ ಹಲವು ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ. ಬಿಟ್ಮ್ಯಾಪ್ ಇಂಡೆಕ್ಸ್‌ಗಳು ಸೇರಿದಂತೆ ಕಸ್ಟಮ್ ಸೇವೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನಾವು ಇದನ್ನು ಮಾಡುತ್ತೇವೆ.
ಹಾಗಾದರೆ ಬಿಟ್ಮ್ಯಾಪ್ ಸೂಚ್ಯಂಕ ಎಂದರೇನು?
ಬಿಟ್ಮ್ಯಾಪ್ ಸೂಚ್ಯಂಕಗಳು, ಹೆಸರೇ ಸೂಚಿಸುವಂತೆ, ಹುಡುಕಾಟ ಸೂಚಿಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬಿಟ್‌ಮ್ಯಾಪ್‌ಗಳು ಅಥವಾ ಬಿಟ್‌ಸೆಟ್‌ಗಳನ್ನು ಬಳಸುತ್ತವೆ. ಪಕ್ಷಿನೋಟದಿಂದ, ಈ ಸೂಚ್ಯಂಕವು ಯಾವುದೇ ಘಟಕಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಒಂದು ಅಥವಾ ಹೆಚ್ಚಿನ ಬಿಟ್ಮ್ಯಾಪ್ಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ (ಉದಾಹರಣೆಗೆ ಜನರು) ಮತ್ತು ಅವುಗಳ ಗುಣಲಕ್ಷಣಗಳು ಅಥವಾ ನಿಯತಾಂಕಗಳು (ವಯಸ್ಸು, ಕಣ್ಣಿನ ಬಣ್ಣ, ಇತ್ಯಾದಿ), ಮತ್ತು ಬಿಟ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಬಳಸುವ ಅಲ್ಗಾರಿದಮ್ (AND, OR, NOT ) ಹುಡುಕಾಟ ಪ್ರಶ್ನೆಗೆ ಉತ್ತರಿಸಲು.
ಕಡಿಮೆ ಕಾರ್ಡಿನಾಲಿಟಿ ಕಾಲಮ್‌ಗಳಾದ್ಯಂತ ("ಕಣ್ಣಿನ ಬಣ್ಣ" ಅಥವಾ "ವೈವಾಹಿಕ ಸ್ಥಿತಿ" ಮತ್ತು "ನಗರ ಕೇಂದ್ರದಿಂದ ದೂರ" ದಂತಹ ಯಾವುದನ್ನಾದರೂ ಯೋಚಿಸಿ) ಪ್ರಶ್ನೆಗಳನ್ನು ಸಂಯೋಜಿಸುವ ಹುಡುಕಾಟಗಳಿರುವ ಸಂದರ್ಭಗಳಲ್ಲಿ ಬಿಟ್ಮ್ಯಾಪ್ ಸೂಚ್ಯಂಕಗಳು ಹೆಚ್ಚು ಸೂಕ್ತವಾಗಿವೆ ಮತ್ತು ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂದು ನಮಗೆ ತಿಳಿಸಲಾಗಿದೆ. ಆದರೆ ಹೆಚ್ಚಿನ ಕಾರ್ಡಿನಾಲಿಟಿ ಕಾಲಮ್‌ಗಳಿಗೆ ಅವು ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂದು ನಾನು ನಂತರ ತೋರಿಸುತ್ತೇನೆ.
ಬಿಟ್ಮ್ಯಾಪ್ ಇಂಡೆಕ್ಸ್‌ನ ಸರಳ ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ.
ಈ ರೀತಿಯ ಬೈನರಿ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹೊಂದಿರುವ ಮಾಸ್ಕೋ ರೆಸ್ಟೋರೆಂಟ್‌ಗಳ ಪಟ್ಟಿಯನ್ನು ನಾವು ಹೊಂದಿದ್ದೇವೆ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ:
- ಮೆಟ್ರೋ ಬಳಿ;
- ಖಾಸಗಿ ಪಾರ್ಕಿಂಗ್ ಇದೆ;
- ವರಾಂಡಾ ಇದೆ (ಟೆರೇಸ್ ಹೊಂದಿದೆ);
- ನೀವು ಟೇಬಲ್ ಕಾಯ್ದಿರಿಸಬಹುದು (ಮೀಸಲಾತಿಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ);
- ಸಸ್ಯಾಹಾರಿಗಳಿಗೆ ಸೂಕ್ತವಾಗಿದೆ (ಸಸ್ಯಾಹಾರಿ ಸ್ನೇಹಿ);
- ದುಬಾರಿ (ದುಬಾರಿ).
ಪ್ರತಿ ರೆಸ್ಟಾರೆಂಟ್‌ಗೆ 0 ರಿಂದ ಪ್ರಾರಂಭವಾಗುವ ಅನುಕ್ರಮ ಸಂಖ್ಯೆಯನ್ನು ನೀಡೋಣ ಮತ್ತು 6 ಬಿಟ್‌ಮ್ಯಾಪ್‌ಗಳಿಗೆ ಮೆಮೊರಿಯನ್ನು ನಿಯೋಜಿಸೋಣ (ಪ್ರತಿ ಗುಣಲಕ್ಷಣಕ್ಕೆ ಒಂದು). ರೆಸ್ಟೋರೆಂಟ್ ಈ ಆಸ್ತಿಯನ್ನು ಹೊಂದಿದೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ ಎಂಬುದನ್ನು ಅವಲಂಬಿಸಿ ನಾವು ನಂತರ ಈ ಬಿಟ್ಮ್ಯಾಪ್ಗಳನ್ನು ಜನಪ್ರಿಯಗೊಳಿಸುತ್ತೇವೆ. ರೆಸ್ಟಾರೆಂಟ್ 4 ವೆರಾಂಡಾವನ್ನು ಹೊಂದಿದ್ದರೆ, ನಂತರ "ವೆರಾಂಡಾ ಹೊಂದಿದೆ" ಬಿಟ್ಮ್ಯಾಪ್ನಲ್ಲಿ ಬಿಟ್ ಸಂಖ್ಯೆ 4 ಅನ್ನು 1 ಕ್ಕೆ ಹೊಂದಿಸಲಾಗುತ್ತದೆ (ಯಾವುದೇ ವೆರಾಂಡಾ ಇಲ್ಲದಿದ್ದರೆ, ನಂತರ 0 ಕ್ಕೆ).
ಈಗ ನಾವು ಸರಳವಾದ ಬಿಟ್ಮ್ಯಾಪ್ ಸೂಚ್ಯಂಕವನ್ನು ಹೊಂದಿದ್ದೇವೆ ಮತ್ತು ಈ ರೀತಿಯ ಪ್ರಶ್ನೆಗಳಿಗೆ ಉತ್ತರಿಸಲು ನಾವು ಇದನ್ನು ಬಳಸಬಹುದು:
- "ನನಗೆ ಸಸ್ಯಾಹಾರಿ-ಸ್ನೇಹಿ ರೆಸ್ಟೋರೆಂಟ್‌ಗಳನ್ನು ತೋರಿಸಿ";
- "ನೀವು ಟೇಬಲ್ ಕಾಯ್ದಿರಿಸಬಹುದಾದ ವರಾಂಡಾದೊಂದಿಗೆ ದುಬಾರಿಯಲ್ಲದ ರೆಸ್ಟೋರೆಂಟ್‌ಗಳನ್ನು ನನಗೆ ತೋರಿಸಿ."
ಹೇಗೆ? ನೋಡೋಣ. ಮೊದಲ ವಿನಂತಿಯು ತುಂಬಾ ಸರಳವಾಗಿದೆ. ನಾವು ಮಾಡಬೇಕಾಗಿರುವುದು “ಸಸ್ಯಾಹಾರಿ ಸ್ನೇಹಿ” ಬಿಟ್ಮ್ಯಾಪ್ ಅನ್ನು ತೆಗೆದುಕೊಂಡು ಅದನ್ನು ಬಿಟ್‌ಗಳನ್ನು ಬಹಿರಂಗಪಡಿಸುವ ರೆಸ್ಟೋರೆಂಟ್‌ಗಳ ಪಟ್ಟಿಯಾಗಿ ಪರಿವರ್ತಿಸುವುದು.
ಎರಡನೆಯ ವಿನಂತಿಯು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾಗಿದೆ. ದುಬಾರಿಯಲ್ಲದ ರೆಸ್ಟೋರೆಂಟ್‌ಗಳ ಪಟ್ಟಿಯನ್ನು ಪಡೆಯಲು ನಾವು "ದುಬಾರಿ" ಬಿಟ್ಮ್ಯಾಪ್ನಲ್ಲಿ NOT ಬಿಟ್ಮ್ಯಾಪ್ ಅನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ, ನಂತರ ಮತ್ತು "ನಾನು ಟೇಬಲ್ ಅನ್ನು ಬುಕ್ ಮಾಡಬಹುದೇ" ಬಿಟ್‌ಮ್ಯಾಪ್‌ನೊಂದಿಗೆ ಮತ್ತು ಮತ್ತು ಫಲಿತಾಂಶವು "ವೆರಾಂಡಾ ಇದೆ" ಬಿಟ್‌ಮ್ಯಾಪ್‌ನೊಂದಿಗೆ. ಪರಿಣಾಮವಾಗಿ ಬಿಟ್ಮ್ಯಾಪ್ ನಮ್ಮ ಎಲ್ಲಾ ಮಾನದಂಡಗಳನ್ನು ಪೂರೈಸುವ ಸಂಸ್ಥೆಗಳ ಪಟ್ಟಿಯನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ಇದು ಯುನೋಸ್ಟ್ ರೆಸ್ಟೋರೆಂಟ್ ಮಾತ್ರ.
ಇದರಲ್ಲಿ ಬಹಳಷ್ಟು ಸಿದ್ಧಾಂತಗಳಿವೆ, ಆದರೆ ಚಿಂತಿಸಬೇಡಿ, ನಾವು ಶೀಘ್ರದಲ್ಲೇ ಕೋಡ್ ಅನ್ನು ನೋಡುತ್ತೇವೆ.
ಬಿಟ್ಮ್ಯಾಪ್ ಸೂಚ್ಯಂಕಗಳನ್ನು ಎಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ?
ನೀವು ಬಿಟ್ಮ್ಯಾಪ್ ಇಂಡೆಕ್ಸ್‌ಗಳನ್ನು ಗೂಗಲ್ ಮಾಡಿದರೆ, 90% ಉತ್ತರಗಳು ಒರಾಕಲ್ ಡಿಬಿಗೆ ಒಂದಲ್ಲ ಒಂದು ರೀತಿಯಲ್ಲಿ ಸಂಬಂಧಿಸಿವೆ. ಆದರೆ ಇತರ DBMS ಗಳು ಬಹುಶಃ ಅಂತಹ ತಂಪಾದ ವಿಷಯವನ್ನು ಬೆಂಬಲಿಸುತ್ತವೆ, ಸರಿ? ನಿಜವಾಗಿಯೂ ಅಲ್ಲ.
ಮುಖ್ಯ ಶಂಕಿತರ ಪಟ್ಟಿಯ ಮೂಲಕ ಹೋಗೋಣ.
MySQL ಇನ್ನೂ ಬಿಟ್ಮ್ಯಾಪ್ ಇಂಡೆಕ್ಸ್‌ಗಳನ್ನು ಬೆಂಬಲಿಸುವುದಿಲ್ಲ, ಆದರೆ ಈ ಆಯ್ಕೆಯನ್ನು ಸೇರಿಸಲು ಸೂಚಿಸುವ ಪ್ರಸ್ತಾಪವಿದೆ ().
PostgreSQL ಬಿಟ್ಮ್ಯಾಪ್ ಇಂಡೆಕ್ಸ್‌ಗಳನ್ನು ಬೆಂಬಲಿಸುವುದಿಲ್ಲ, ಆದರೆ ಅನೇಕ ಇತರ ಸೂಚಿಕೆಗಳಲ್ಲಿ ಹುಡುಕಾಟ ಫಲಿತಾಂಶಗಳನ್ನು ಸಂಯೋಜಿಸಲು ಸರಳ ಬಿಟ್‌ಮ್ಯಾಪ್‌ಗಳು ಮತ್ತು ಬಿಟ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಬಳಸುತ್ತದೆ.
Tarantool ಬಿಟ್‌ಸೆಟ್ ಇಂಡೆಕ್ಸ್‌ಗಳನ್ನು ಹೊಂದಿದೆ ಮತ್ತು ಅವುಗಳ ಮೇಲೆ ಸರಳ ಹುಡುಕಾಟಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ.
У Redis есть простые битовые поля) ಅವುಗಳನ್ನು ಹುಡುಕುವ ಸಾಮರ್ಥ್ಯವಿಲ್ಲದೆ.
MongoDB ಇನ್ನೂ ಬಿಟ್ಮ್ಯಾಪ್ ಇಂಡೆಕ್ಸ್‌ಗಳನ್ನು ಬೆಂಬಲಿಸುವುದಿಲ್ಲ, ಆದರೆ ಈ ಆಯ್ಕೆಯನ್ನು ಸೇರಿಸಲು ಸೂಚಿಸುವ ಪ್ರಸ್ತಾಪವೂ ಇದೆ.
Elasticsearch ಆಂತರಿಕವಾಗಿ ಬಿಟ್ಮ್ಯಾಪ್ಗಳನ್ನು ಬಳಸುತ್ತದೆ).
- ಆದರೆ ನಮ್ಮ ಮನೆಯಲ್ಲಿ ಹೊಸ ನೆರೆಹೊರೆಯವರು ಕಾಣಿಸಿಕೊಂಡಿದ್ದಾರೆ: ಪಿಲೋಸಾ. ಇದು Go ನಲ್ಲಿ ಬರೆಯಲಾದ ಹೊಸ ಸಂಬಂಧವಿಲ್ಲದ ಡೇಟಾಬೇಸ್ ಆಗಿದೆ. ಇದು ಬಿಟ್ಮ್ಯಾಪ್ ಇಂಡೆಕ್ಸ್‌ಗಳನ್ನು ಮಾತ್ರ ಒಳಗೊಂಡಿದೆ ಮತ್ತು ಅವುಗಳ ಮೇಲೆ ಎಲ್ಲವನ್ನೂ ಆಧರಿಸಿದೆ. ನಾವು ಸ್ವಲ್ಪ ಸಮಯದ ನಂತರ ಅದರ ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತೇವೆ.
ಗೋದಲ್ಲಿ ಅನುಷ್ಠಾನ
ಆದರೆ ಬಿಟ್ಮ್ಯಾಪ್ ಸೂಚ್ಯಂಕಗಳನ್ನು ಏಕೆ ವಿರಳವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ? ಈ ಪ್ರಶ್ನೆಗೆ ಉತ್ತರಿಸುವ ಮೊದಲು, Go ನಲ್ಲಿ ಸರಳವಾದ ಬಿಟ್ಮ್ಯಾಪ್ ಸೂಚಿಯನ್ನು ಹೇಗೆ ಕಾರ್ಯಗತಗೊಳಿಸುವುದು ಎಂದು ನಾನು ನಿಮಗೆ ತೋರಿಸಲು ಬಯಸುತ್ತೇನೆ.
ಬಿಟ್‌ಮ್ಯಾಪ್‌ಗಳು ಮೂಲಭೂತವಾಗಿ ಡೇಟಾದ ತುಣುಕುಗಳಾಗಿವೆ. ಗೋದಲ್ಲಿ, ಇದಕ್ಕಾಗಿ ಬೈಟ್ ಸ್ಲೈಸ್‌ಗಳನ್ನು ಬಳಸೋಣ.
ಒಂದು ರೆಸ್ಟೋರೆಂಟ್ ಗುಣಲಕ್ಷಣಕ್ಕಾಗಿ ನಾವು ಒಂದು ಬಿಟ್ಮ್ಯಾಪ್ ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ ಮತ್ತು ಬಿಟ್‌ಮ್ಯಾಪ್‌ನಲ್ಲಿರುವ ಪ್ರತಿ ಬಿಟ್ ನಿರ್ದಿಷ್ಟ ರೆಸ್ಟೋರೆಂಟ್ ಈ ಆಸ್ತಿಯನ್ನು ಹೊಂದಿದೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ ಎಂಬುದನ್ನು ಸೂಚಿಸುತ್ತದೆ.
ನಮಗೆ ಎರಡು ಸಹಾಯಕ ಕಾರ್ಯಗಳು ಬೇಕಾಗುತ್ತವೆ. ಯಾದೃಚ್ಛಿಕ ಡೇಟಾದೊಂದಿಗೆ ನಮ್ಮ ಬಿಟ್ಮ್ಯಾಪ್ಗಳನ್ನು ತುಂಬಲು ಒಂದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಯಾದೃಚ್ಛಿಕ, ಆದರೆ ರೆಸ್ಟೋರೆಂಟ್ ಪ್ರತಿಯೊಂದು ಆಸ್ತಿಯನ್ನು ಹೊಂದಿರುವ ಒಂದು ನಿರ್ದಿಷ್ಟ ಸಂಭವನೀಯತೆಯೊಂದಿಗೆ. ಉದಾಹರಣೆಗೆ, ಮಾಸ್ಕೋದಲ್ಲಿ ನೀವು ಟೇಬಲ್ ಅನ್ನು ಕಾಯ್ದಿರಿಸಲಾಗದ ಕೆಲವೇ ರೆಸ್ಟೋರೆಂಟ್‌ಗಳಿವೆ ಎಂದು ನಾನು ನಂಬುತ್ತೇನೆ ಮತ್ತು ಸುಮಾರು 20% ಸಂಸ್ಥೆಗಳು ಸಸ್ಯಾಹಾರಿಗಳಿಗೆ ಸೂಕ್ತವಾಗಿದೆ ಎಂದು ನನಗೆ ತೋರುತ್ತದೆ.
ಎರಡನೇ ಕಾರ್ಯವು ಬಿಟ್ಮ್ಯಾಪ್ ಅನ್ನು ರೆಸ್ಟೋರೆಂಟ್‌ಗಳ ಪಟ್ಟಿಗೆ ಪರಿವರ್ತಿಸುತ್ತದೆ.
"ಒಂದು ಒಳಾಂಗಣವನ್ನು ಹೊಂದಿರುವ ಮತ್ತು ಕಾಯ್ದಿರಿಸಬಹುದಾದ ದುಬಾರಿಯಲ್ಲದ ರೆಸ್ಟೋರೆಂಟ್‌ಗಳನ್ನು ನನಗೆ ತೋರಿಸಿ" ಎಂಬ ಪ್ರಶ್ನೆಗೆ ಉತ್ತರಿಸಲು ನಮಗೆ ಎರಡು ಬಿಟ್ ಕಾರ್ಯಾಚರಣೆಗಳ ಅಗತ್ಯವಿದೆ: NOT ಮತ್ತು AND.
ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಮತ್ತು ಆಪರೇಟರ್ ಅಲ್ಲದ ಮೂಲಕ ನಾವು ನಮ್ಮ ಕೋಡ್ ಅನ್ನು ಸ್ವಲ್ಪ ಸರಳಗೊಳಿಸಬಹುದು.
ಈ ಪ್ರತಿಯೊಂದು ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ನಾವು ಕಾರ್ಯಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ. ಇವೆರಡೂ ಸ್ಲೈಸ್‌ಗಳ ಮೂಲಕ ಹೋಗಿ, ಪ್ರತಿಯೊಂದರಿಂದಲೂ ಅನುಗುಣವಾದ ಅಂಶಗಳನ್ನು ತೆಗೆದುಕೊಂಡು, ಅವುಗಳನ್ನು ಸ್ವಲ್ಪ ಕಾರ್ಯಾಚರಣೆಯೊಂದಿಗೆ ಸಂಯೋಜಿಸಿ ಮತ್ತು ಫಲಿತಾಂಶವನ್ನು ಪರಿಣಾಮವಾಗಿ ಸ್ಲೈಸ್‌ಗೆ ಹಾಕಿ.
ಮತ್ತು ಈಗ ನಾವು ಹುಡುಕಾಟ ಪ್ರಶ್ನೆಗೆ ಉತ್ತರಿಸಲು ನಮ್ಮ ಬಿಟ್‌ಮ್ಯಾಪ್‌ಗಳು ಮತ್ತು ಕಾರ್ಯಗಳನ್ನು ಬಳಸಬಹುದು.
ಕಾರ್ಯಗಳು ತುಂಬಾ ಸರಳವಾಗಿದ್ದರೂ ಕಾರ್ಯಕ್ಷಮತೆಯು ಅಷ್ಟು ಹೆಚ್ಚಿಲ್ಲ ಮತ್ತು ಪ್ರತಿ ಬಾರಿ ಫಂಕ್ಷನ್‌ಗೆ ಕರೆ ಮಾಡಿದಾಗ ಹೊಸ ಫಲಿತಾಂಶದ ಸ್ಲೈಸ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸದೆ ನಾವು ಬಹಳಷ್ಟು ಹಣವನ್ನು ಉಳಿಸಿದ್ದೇವೆ.
pprof ನೊಂದಿಗೆ ಸ್ವಲ್ಪ ಪ್ರೊಫೈಲಿಂಗ್ ಮಾಡಿದ ನಂತರ, Go ಕಂಪೈಲರ್ ಅತ್ಯಂತ ಸರಳವಾದ ಆದರೆ ಬಹಳ ಮುಖ್ಯವಾದ ಆಪ್ಟಿಮೈಸೇಶನ್ ಅನ್ನು ಕಳೆದುಕೊಂಡಿರುವುದನ್ನು ನಾನು ಗಮನಿಸಿದೆ: ಫಂಕ್ಷನ್ ಇನ್ಲೈನಿಂಗ್.
ಸತ್ಯವೆಂದರೆ ಗೋ ಕಂಪೈಲರ್ ಸ್ಲೈಸ್‌ಗಳ ಮೂಲಕ ಹೋಗುವ ಲೂಪ್‌ಗಳಿಗೆ ಭಯಂಕರವಾಗಿ ಹೆದರುತ್ತದೆ ಮತ್ತು ಅಂತಹ ಲೂಪ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಇನ್ಲೈನ್ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ದಿಷ್ಟವಾಗಿ ನಿರಾಕರಿಸುತ್ತದೆ.
ಆದರೆ ನಾನು ಹೆದರುವುದಿಲ್ಲ ಮತ್ತು ಹಳೆಯ ದಿನಗಳಲ್ಲಿ ಲೂಪ್ ಬದಲಿಗೆ ಗೊಟೊವನ್ನು ಬಳಸುವ ಮೂಲಕ ನಾನು ಕಂಪೈಲರ್ ಅನ್ನು ಮರುಳುಗೊಳಿಸಬಹುದು.
ಮತ್ತು, ನೀವು ನೋಡುವಂತೆ, ಈಗ ಕಂಪೈಲರ್ ನಮ್ಮ ಕಾರ್ಯವನ್ನು ಸಂತೋಷದಿಂದ ಇನ್ಲೈನ್ ಮಾಡುತ್ತದೆ! ಪರಿಣಾಮವಾಗಿ, ನಾವು ಸುಮಾರು 2 ಮೈಕ್ರೋಸೆಕೆಂಡ್‌ಗಳನ್ನು ಉಳಿಸಲು ನಿರ್ವಹಿಸುತ್ತೇವೆ. ಕೆಟ್ಟದ್ದಲ್ಲ!
ನೀವು ಅಸೆಂಬ್ಲಿ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಹತ್ತಿರದಿಂದ ನೋಡಿದರೆ ಎರಡನೇ ಅಡಚಣೆಯನ್ನು ನೋಡುವುದು ಸುಲಭ. ಕಂಪೈಲರ್ ನಮ್ಮ ಹಾಟೆಸ್ಟ್ ಲೂಪ್ ಒಳಗೆ ಸ್ಲೈಸ್ ಬೌಂಡರಿ ಚೆಕ್ ಅನ್ನು ಸೇರಿಸಿದೆ. ಸತ್ಯವೆಂದರೆ ಗೋ ಸುರಕ್ಷಿತ ಭಾಷೆಯಾಗಿದೆ, ನನ್ನ ಮೂರು ವಾದಗಳು (ಮೂರು ಸ್ಲೈಸ್‌ಗಳು) ವಿಭಿನ್ನ ಗಾತ್ರಗಳಲ್ಲಿವೆ ಎಂದು ಕಂಪೈಲರ್ ಹೆದರುತ್ತಾನೆ. ಎಲ್ಲಾ ನಂತರ, ನಂತರ ಬಫರ್ ಓವರ್ಫ್ಲೋ ಎಂದು ಕರೆಯಲ್ಪಡುವ ಸಂಭವಿಸುವ ಸೈದ್ಧಾಂತಿಕ ಸಾಧ್ಯತೆ ಇರುತ್ತದೆ.
ಎಲ್ಲಾ ಸ್ಲೈಸ್‌ಗಳು ಒಂದೇ ಗಾತ್ರದಲ್ಲಿವೆ ಎಂದು ತೋರಿಸುವ ಮೂಲಕ ಕಂಪೈಲರ್‌ಗೆ ಭರವಸೆ ನೀಡೋಣ. ನಮ್ಮ ಕಾರ್ಯದ ಆರಂಭದಲ್ಲಿ ಸರಳವಾದ ಚೆಕ್ ಅನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ನಾವು ಇದನ್ನು ಮಾಡಬಹುದು.
ಇದನ್ನು ನೋಡಿ, ಕಂಪೈಲರ್ ಸಂತೋಷದಿಂದ ಚೆಕ್ ಅನ್ನು ಬಿಟ್ಟುಬಿಡುತ್ತಾನೆ ಮತ್ತು ನಾವು ಇನ್ನೂ 500 ನ್ಯಾನೊಸೆಕೆಂಡ್‌ಗಳನ್ನು ಉಳಿಸುತ್ತೇವೆ.
ದೊಡ್ಡ ಕಟುಗಳು
ಸರಿ, ನಮ್ಮ ಸರಳವಾದ ಅನುಷ್ಠಾನದಿಂದ ನಾವು ಕೆಲವು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಹಿಂಡುವಲ್ಲಿ ಯಶಸ್ವಿಯಾಗಿದ್ದೇವೆ, ಆದರೆ ಈ ಫಲಿತಾಂಶವು ಪ್ರಸ್ತುತ ಹಾರ್ಡ್‌ವೇರ್‌ನಲ್ಲಿ ಸಾಧ್ಯವಾಗುವುದಕ್ಕಿಂತ ಹೆಚ್ಚು ಕೆಟ್ಟದಾಗಿದೆ.
ನಾವು ಮಾಡುವುದೆಲ್ಲವೂ ಮೂಲಭೂತ ಬಿಟ್ ಕಾರ್ಯಾಚರಣೆಗಳು ಮತ್ತು ನಮ್ಮ ಪ್ರೊಸೆಸರ್‌ಗಳು ಅವುಗಳನ್ನು ಅತ್ಯಂತ ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿರ್ವಹಿಸುತ್ತವೆ. ಆದರೆ, ದುರದೃಷ್ಟವಶಾತ್, ನಾವು ನಮ್ಮ ಪ್ರೊಸೆಸರ್ ಅನ್ನು ಬಹಳ ಸಣ್ಣ ಕೆಲಸಗಳೊಂದಿಗೆ "ಫೀಡ್" ಮಾಡುತ್ತೇವೆ. ನಮ್ಮ ಕಾರ್ಯಗಳು ಬೈಟ್-ಬೈಟ್ ಆಧಾರದ ಮೇಲೆ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತವೆ. UInt8 ಸ್ಲೈಸ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು 64-ಬೈಟ್ ಭಾಗಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ನಾವು ನಮ್ಮ ಕೋಡ್ ಅನ್ನು ಸುಲಭವಾಗಿ ತಿರುಚಬಹುದು.
ನೀವು ನೋಡುವಂತೆ, ಈ ಸಣ್ಣ ಬದಲಾವಣೆಯು ಬ್ಯಾಚ್ ಗಾತ್ರವನ್ನು ಎಂಟು ಪಟ್ಟು ಹೆಚ್ಚಿಸುವ ಮೂಲಕ ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಎಂಟು ಬಾರಿ ವೇಗಗೊಳಿಸಿತು. ಗಳಿಕೆಯನ್ನು ರೇಖೀಯ ಎಂದು ಹೇಳಬಹುದು.
ಅಸೆಂಬ್ಲರ್ನಲ್ಲಿ ಅನುಷ್ಠಾನ
ಆದರೆ ಇದು ಅಂತ್ಯವಲ್ಲ. ನಮ್ಮ ಪ್ರೊಸೆಸರ್‌ಗಳು 16, 32 ಮತ್ತು 64 ಬೈಟ್‌ಗಳ ಭಾಗಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಬಹುದು. ಅಂತಹ "ವಿಶಾಲ" ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಏಕ ಸೂಚನಾ ಬಹು ಡೇಟಾ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ (SIMD; ಒಂದು ಸೂಚನೆ, ಅನೇಕ ಡೇಟಾ), ಮತ್ತು ಅಂತಹ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಬಳಸುವ ಕೋಡ್ ಅನ್ನು ಪರಿವರ್ತಿಸುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ವೆಕ್ಟರೈಸೇಶನ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.
ದುರದೃಷ್ಟವಶಾತ್, ಗೋ ಕಂಪೈಲರ್ ವೆಕ್ಟರೈಸೇಶನ್‌ನಲ್ಲಿ ಉತ್ತಮವಾಗಿಲ್ಲ. ಪ್ರಸ್ತುತ, ಗೋ ಅಸೆಂಬ್ಲರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಈ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ತೆಗೆದುಕೊಳ್ಳುವುದು ಮತ್ತು ಹಾಕುವುದು ಗೋ ಕೋಡ್ ಅನ್ನು ವೆಕ್ಟರೈಸ್ ಮಾಡುವ ಏಕೈಕ ಮಾರ್ಗವಾಗಿದೆ.
ಗೋ ಜೋಡಿಸುವವನು ವಿಚಿತ್ರ ಪ್ರಾಣಿ. ಅಸೆಂಬ್ಲಿ ಭಾಷೆಯು ನೀವು ಬರೆಯುತ್ತಿರುವ ಕಂಪ್ಯೂಟರ್‌ನ ಆರ್ಕಿಟೆಕ್ಚರ್‌ಗೆ ಹೆಚ್ಚು ಸಂಬಂಧ ಹೊಂದಿದೆ ಎಂದು ನಿಮಗೆ ತಿಳಿದಿರಬಹುದು, ಆದರೆ ಗೋದಲ್ಲಿ ಅದು ಹಾಗಲ್ಲ. ಗೋ ಅಸೆಂಬ್ಲರ್ IRL (ಮಧ್ಯಂತರ ಪ್ರಾತಿನಿಧ್ಯ ಭಾಷೆ) ಅಥವಾ ಮಧ್ಯಂತರ ಭಾಷೆಯಂತಿದೆ: ಇದು ಪ್ರಾಯೋಗಿಕವಾಗಿ ಸ್ವತಂತ್ರ ವೇದಿಕೆಯಾಗಿದೆ. ರಾಬ್ ಪೈಕ್ ಅತ್ಯುತ್ತಮ ಪ್ರದರ್ಶನ ನೀಡಿದರು ಹಲವಾರು ವರ್ಷಗಳ ಹಿಂದೆ ಡೆನ್ವರ್‌ನ ಗೋಫರ್‌ಕಾನ್‌ನಲ್ಲಿ ಈ ವಿಷಯದ ಕುರಿತು.
ಹೆಚ್ಚುವರಿಯಾಗಿ, Go ಅಸಾಮಾನ್ಯವಾದ ಯೋಜನೆ 9 ಸ್ವರೂಪವನ್ನು ಬಳಸುತ್ತದೆ, ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಅಂಗೀಕರಿಸಲ್ಪಟ್ಟ AT&T ಮತ್ತು Intel ಸ್ವರೂಪಗಳಿಂದ ಭಿನ್ನವಾಗಿದೆ.
ಗೋ ಅಸೆಂಬ್ಲರ್ ಅನ್ನು ಕೈಯಿಂದ ಬರೆಯುವುದು ಅತ್ಯಂತ ಮೋಜಿನ ಸಂಗತಿಯಲ್ಲ ಎಂದು ಹೇಳುವುದು ಸುರಕ್ಷಿತವಾಗಿದೆ.
ಆದರೆ, ಅದೃಷ್ಟವಶಾತ್, ಗೋ ಅಸೆಂಬ್ಲರ್ ಅನ್ನು ಬರೆಯಲು ನಮಗೆ ಸಹಾಯ ಮಾಡುವ ಎರಡು ಉನ್ನತ ಮಟ್ಟದ ಪರಿಕರಗಳು ಈಗಾಗಲೇ ಇವೆ: ಪೀಚ್‌ಪಿ ಮತ್ತು ಅವೊ. ಎರಡೂ ಉಪಯುಕ್ತತೆಗಳು ಕ್ರಮವಾಗಿ ಪೈಥಾನ್ ಮತ್ತು ಗೋದಲ್ಲಿ ಬರೆಯಲಾದ ಉನ್ನತ ಮಟ್ಟದ ಕೋಡ್‌ನಿಂದ ಗೋ ಅಸೆಂಬ್ಲರ್ ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತವೆ.
ಈ ಉಪಯುಕ್ತತೆಗಳು ರಿಜಿಸ್ಟರ್ ಹಂಚಿಕೆ, ಬರೆಯುವ ಲೂಪ್‌ಗಳಂತಹ ವಿಷಯಗಳನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ ಗೋದಲ್ಲಿ ಅಸೆಂಬ್ಲಿ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಜಗತ್ತಿನಲ್ಲಿ ಪ್ರವೇಶಿಸುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ.
ನಾವು avo ಅನ್ನು ಬಳಸುತ್ತೇವೆ, ಆದ್ದರಿಂದ ನಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳು ಬಹುತೇಕ ಸಾಮಾನ್ಯ Go ಕಾರ್ಯಕ್ರಮಗಳಾಗಿರುತ್ತದೆ.
avo ಪ್ರೋಗ್ರಾಂನ ಸರಳ ಉದಾಹರಣೆ ಹೀಗಿದೆ. ನಾವು ಒಂದು ಮುಖ್ಯ () ಕಾರ್ಯವನ್ನು ಹೊಂದಿದ್ದೇವೆ, ಅದು ಅದರೊಳಗೆ ಸೇರಿಸು () ಕಾರ್ಯವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ, ಇದರ ಅರ್ಥ ಎರಡು ಸಂಖ್ಯೆಗಳನ್ನು ಸೇರಿಸುವುದು. ಹೆಸರಿನಿಂದ ನಿಯತಾಂಕಗಳನ್ನು ಪಡೆಯಲು ಮತ್ತು ಉಚಿತ ಮತ್ತು ಸೂಕ್ತವಾದ ಪ್ರೊಸೆಸರ್ ರೆಜಿಸ್ಟರ್‌ಗಳಲ್ಲಿ ಒಂದನ್ನು ಪಡೆಯಲು ಇಲ್ಲಿ ಸಹಾಯಕ ಕಾರ್ಯಗಳಿವೆ. ADDQ ನಲ್ಲಿ ನೋಡಿದಂತೆ ಪ್ರತಿಯೊಂದು ಪ್ರೊಸೆಸರ್ ಕಾರ್ಯಾಚರಣೆಯು avo ನಲ್ಲಿ ಅನುಗುಣವಾದ ಕಾರ್ಯವನ್ನು ಹೊಂದಿದೆ. ಅಂತಿಮವಾಗಿ, ಫಲಿತಾಂಶದ ಮೌಲ್ಯವನ್ನು ಸಂಗ್ರಹಿಸಲು ನಾವು ಸಹಾಯಕ ಕಾರ್ಯವನ್ನು ನೋಡುತ್ತೇವೆ.
ಗೋ ಜನರೇಟ್ ಎಂದು ಕರೆಯುವ ಮೂಲಕ, ನಾವು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು avo ನಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತೇವೆ ಮತ್ತು ಪರಿಣಾಮವಾಗಿ, ಎರಡು ಫೈಲ್‌ಗಳನ್ನು ರಚಿಸಲಾಗುತ್ತದೆ:
- ಗೋ ಅಸೆಂಬ್ಲರ್ನಲ್ಲಿ ಪರಿಣಾಮವಾಗಿ ಕೋಡ್‌ನೊಂದಿಗೆ add.s;
- ಎರಡು ಪ್ರಪಂಚಗಳನ್ನು ಸಂಪರ್ಕಿಸಲು ಫಂಕ್ಷನ್ ಹೆಡರ್‌ಗಳೊಂದಿಗೆ stub.go: ಹೋಗಿ ಮತ್ತು ಅಸೆಂಬ್ಲರ್.
ಈಗ ನಾವು ಅವೊ ಏನು ಮಾಡುತ್ತದೆ ಮತ್ತು ಹೇಗೆ ಎಂದು ನೋಡಿದ್ದೇವೆ, ನಮ್ಮ ಕಾರ್ಯಗಳನ್ನು ನೋಡೋಣ. ನಾನು ಫಂಕ್ಷನ್‌ಗಳ ಸ್ಕೇಲಾರ್ ಮತ್ತು ವೆಕ್ಟರ್ (SIMD) ಆವೃತ್ತಿಗಳನ್ನು ಅಳವಡಿಸಿದ್ದೇನೆ.
ಮೊದಲು ಸ್ಕೇಲಾರ್ ಆವೃತ್ತಿಗಳನ್ನು ನೋಡೋಣ.
ಹಿಂದಿನ ಉದಾಹರಣೆಯಂತೆ, ನಾವು ಉಚಿತ ಮತ್ತು ಮಾನ್ಯವಾದ ಸಾಮಾನ್ಯ ಉದ್ದೇಶದ ರಿಜಿಸ್ಟರ್ಗಾಗಿ ಕೇಳುತ್ತಿದ್ದೇವೆ, ನಾವು ವಾದಗಳಿಗೆ ಆಫ್‌ಸೆಟ್‌ಗಳು ಮತ್ತು ಗಾತ್ರಗಳನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವ ಅಗತ್ಯವಿಲ್ಲ. avo ನಮಗಾಗಿ ಇದೆಲ್ಲವನ್ನೂ ಮಾಡುತ್ತದೆ.
Ранее мы использовали лейблы и goto (или прыжки) для повышения производительности и для того чтобы обмануть компилятор Go, но сейчас мы делаем это с самого начала. Дело в том, что циклы — это более высокоуровневое понятие. В ассемблере же у нас есть только лейблы и прыжки.
ಉಳಿದ ಕೋಡ್ ಈಗಾಗಲೇ ಪರಿಚಿತ ಮತ್ತು ಅರ್ಥವಾಗುವಂತಹದ್ದಾಗಿರಬೇಕು. ನಾವು ಲೇಬಲ್‌ಗಳು ಮತ್ತು ಜಿಗಿತಗಳೊಂದಿಗೆ ಲೂಪ್ ಅನ್ನು ಅನುಕರಿಸುತ್ತೇವೆ, ನಮ್ಮ ಎರಡು ಸ್ಲೈಸ್‌ಗಳಿಂದ ಒಂದು ಸಣ್ಣ ಡೇಟಾವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ, ಅವುಗಳನ್ನು ಸ್ವಲ್ಪ ಕಾರ್ಯಾಚರಣೆಯೊಂದಿಗೆ ಸಂಯೋಜಿಸುತ್ತೇವೆ (ಮತ್ತು ಈ ಸಂದರ್ಭದಲ್ಲಿ ಅಲ್ಲ) ಮತ್ತು ನಂತರ ಫಲಿತಾಂಶವನ್ನು ಪರಿಣಾಮವಾಗಿ ಸ್ಲೈಸ್‌ಗೆ ಹಾಕುತ್ತೇವೆ. ಎಲ್ಲಾ.
ಅಂತಿಮ ಅಸೆಂಬ್ಲರ್ ಕೋಡ್ ಈ ರೀತಿ ಕಾಣುತ್ತದೆ. ನಾವು ಆಫ್‌ಸೆಟ್‌ಗಳು ಮತ್ತು ಗಾತ್ರಗಳನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಬೇಕಾಗಿಲ್ಲ (ಹಸಿರು ಬಣ್ಣದಲ್ಲಿ ಹೈಲೈಟ್ ಮಾಡಲಾಗಿದೆ) ಅಥವಾ ಬಳಸಿದ ರೆಜಿಸ್ಟರ್ಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಬೇಕಾಗಿಲ್ಲ (ಕೆಂಪು ಬಣ್ಣದಲ್ಲಿ ಹೈಲೈಟ್ ಮಾಡಲಾಗಿದೆ).
ಅಸೆಂಬ್ಲಿ ಭಾಷಾ ಅನುಷ್ಠಾನದ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ನಾವು ಗೋದಲ್ಲಿನ ಅತ್ಯುತ್ತಮ ಅನುಷ್ಠಾನದ ಕಾರ್ಯಕ್ಷಮತೆಯೊಂದಿಗೆ ಹೋಲಿಸಿದರೆ, ಅದು ಒಂದೇ ಆಗಿರುವುದನ್ನು ನಾವು ನೋಡುತ್ತೇವೆ. ಮತ್ತು ಇದನ್ನು ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ. ಎಲ್ಲಾ ನಂತರ, ನಾವು ವಿಶೇಷವಾದ ಏನನ್ನೂ ಮಾಡಿಲ್ಲ - ಗೋ ಕಂಪೈಲರ್ ಏನು ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ನಾವು ಪುನರುತ್ಪಾದಿಸಿದ್ದೇವೆ.
ದುರದೃಷ್ಟವಶಾತ್, ಅಸೆಂಬ್ಲಿ ಭಾಷೆಯಲ್ಲಿ ಬರೆಯಲಾದ ನಮ್ಮ ಕಾರ್ಯಗಳನ್ನು ಇನ್ಲೈನ್ ಮಾಡಲು ನಾವು ಕಂಪೈಲರ್ ಅನ್ನು ಒತ್ತಾಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. Go ಕಂಪೈಲರ್ ಪ್ರಸ್ತುತ ಅಂತಹ ವೈಶಿಷ್ಟ್ಯವನ್ನು ಹೊಂದಿಲ್ಲ, ಆದರೂ ಅದನ್ನು ಸೇರಿಸಲು ಸ್ವಲ್ಪ ಸಮಯದಿಂದ ವಿನಂತಿಸಲಾಗಿದೆ.
ಇದಕ್ಕಾಗಿಯೇ ಅಸೆಂಬ್ಲಿ ಭಾಷೆಯಲ್ಲಿ ಸಣ್ಣ ಕಾರ್ಯಗಳಿಂದ ಯಾವುದೇ ಪ್ರಯೋಜನವನ್ನು ಪಡೆಯುವುದು ಅಸಾಧ್ಯ. ನಾವು ದೊಡ್ಡ ಕಾರ್ಯಗಳನ್ನು ಬರೆಯಬೇಕು ಅಥವಾ ಹೊಸ ಗಣಿತ/ಬಿಟ್‌ಗಳ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಬಳಸಬೇಕು ಅಥವಾ ಅಸೆಂಬ್ಲರ್ ಭಾಷೆಯನ್ನು ಬೈಪಾಸ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ.
ಈಗ ನಮ್ಮ ಕಾರ್ಯಗಳ ವೆಕ್ಟರ್ ಆವೃತ್ತಿಗಳನ್ನು ನೋಡೋಣ.
ಈ ಉದಾಹರಣೆಗಾಗಿ, ನಾನು AVX2 ಅನ್ನು ಬಳಸಲು ನಿರ್ಧರಿಸಿದೆ, ಆದ್ದರಿಂದ ನಾವು 32-ಬೈಟ್ ಭಾಗಗಳಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಬಳಸುತ್ತೇವೆ. ಕೋಡ್ನ ರಚನೆಯು ಸ್ಕೇಲಾರ್ ಆವೃತ್ತಿಗೆ ಹೋಲುತ್ತದೆ: ಪ್ಯಾರಾಮೀಟರ್ಗಳನ್ನು ಲೋಡ್ ಮಾಡುವುದು, ಉಚಿತ ಹಂಚಿಕೆಯ ರಿಜಿಸ್ಟರ್ಗಾಗಿ ಕೇಳುವುದು, ಇತ್ಯಾದಿ.
ಒಂದು ಆವಿಷ್ಕಾರವೆಂದರೆ ವಿಶಾಲವಾದ ವೆಕ್ಟರ್ ಕಾರ್ಯಾಚರಣೆಗಳು ವಿಶೇಷ ವಿಶಾಲ ರೆಜಿಸ್ಟರ್ಗಳನ್ನು ಬಳಸುತ್ತವೆ. 32-ಬೈಟ್ ಭಾಗಗಳ ಸಂದರ್ಭದಲ್ಲಿ, ಇವುಗಳು Y ನೊಂದಿಗೆ ಪೂರ್ವಪ್ರತ್ಯಯವಾಗಿರುವ ರೆಜಿಸ್ಟರ್‌ಗಳಾಗಿವೆ. ಅದಕ್ಕಾಗಿಯೇ ನೀವು ಕೋಡ್‌ನಲ್ಲಿ YMM() ಕಾರ್ಯವನ್ನು ನೋಡುತ್ತೀರಿ. ನಾನು 512-ಬಿಟ್ ಭಾಗಗಳೊಂದಿಗೆ AVX-64 ಅನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ, ಪೂರ್ವಪ್ರತ್ಯಯವು Z ಆಗಿರುತ್ತದೆ.
ಎರಡನೆಯ ಆವಿಷ್ಕಾರವೆಂದರೆ ನಾನು ಲೂಪ್ ಅನ್‌ರೋಲಿಂಗ್ ಎಂಬ ಆಪ್ಟಿಮೈಸೇಶನ್ ಅನ್ನು ಬಳಸಲು ನಿರ್ಧರಿಸಿದೆ, ಅಂದರೆ ಲೂಪ್‌ನ ಪ್ರಾರಂಭಕ್ಕೆ ಜಿಗಿಯುವ ಮೊದಲು ಎಂಟು ಲೂಪ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ಮಾಡುವುದು. ಈ ಆಪ್ಟಿಮೈಸೇಶನ್ ಕೋಡ್‌ನಲ್ಲಿನ ಶಾಖೆಗಳ ಸಂಖ್ಯೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಲಭ್ಯವಿರುವ ಉಚಿತ ರೆಜಿಸ್ಟರ್‌ಗಳ ಸಂಖ್ಯೆಯಿಂದ ಸೀಮಿತವಾಗಿದೆ.
ಸರಿ, ಕಾರ್ಯಕ್ಷಮತೆಯ ಬಗ್ಗೆ ಏನು? ಅವಳು ಸುಂದರವಾಗಿದ್ದಾಳೆ! ಅತ್ಯುತ್ತಮ ಗೋ ಪರಿಹಾರಕ್ಕೆ ಹೋಲಿಸಿದರೆ ನಾವು ಸುಮಾರು ಏಳು ಪಟ್ಟು ವೇಗವನ್ನು ಸಾಧಿಸಿದ್ದೇವೆ. ಪ್ರಭಾವಶಾಲಿ, ಸರಿ?
ಆದರೆ ಈ ಅಳವಡಿಕೆಯನ್ನು ಸಹ AVX-512, ಪ್ರಿಫೆಚಿಂಗ್ ಅಥವಾ JIT (ಜಸ್ಟ್-ಇನ್-ಟೈಮ್ ಕಂಪೈಲರ್) ಅನ್ನು ಕ್ವೆರಿ ಶೆಡ್ಯೂಲರ್‌ಗಾಗಿ ಬಳಸುವ ಮೂಲಕ ವೇಗಗೊಳಿಸಬಹುದು. ಆದರೆ ಇದು ಖಂಡಿತವಾಗಿಯೂ ಪ್ರತ್ಯೇಕ ವರದಿಗಾಗಿ ಒಂದು ವಿಷಯವಾಗಿದೆ.
ಬಿಟ್ಮ್ಯಾಪ್ ಇಂಡೆಕ್ಸ್‌ಗಳೊಂದಿಗಿನ ತೊಂದರೆಗಳು
ಈಗ ನಾವು ಈಗಾಗಲೇ Go ನಲ್ಲಿ ಬಿಟ್ಮ್ಯಾಪ್ ಸೂಚ್ಯಂಕದ ಸರಳ ಅನುಷ್ಠಾನವನ್ನು ಮತ್ತು ಅಸೆಂಬ್ಲಿ ಭಾಷೆಯಲ್ಲಿ ಹೆಚ್ಚು ಉತ್ಪಾದಕವನ್ನು ನೋಡಿದ್ದೇವೆ, ಬಿಟ್ಮ್ಯಾಪ್ ಇಂಡೆಕ್ಸ್‌ಗಳನ್ನು ಏಕೆ ವಿರಳವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ ಎಂಬುದರ ಕುರಿತು ಅಂತಿಮವಾಗಿ ಮಾತನಾಡೋಣ.
ಹಳೆಯ ಪೇಪರ್‌ಗಳು ಬಿಟ್ಮ್ಯಾಪ್ ಇಂಡೆಕ್ಸ್‌ಗಳೊಂದಿಗೆ ಮೂರು ಸಮಸ್ಯೆಗಳನ್ನು ಉಲ್ಲೇಖಿಸುತ್ತವೆ, ಆದರೆ ಹೊಸ ಪೇಪರ್‌ಗಳು ಮತ್ತು ಅವು ಇನ್ನು ಮುಂದೆ ಸಂಬಂಧಿತವಾಗಿಲ್ಲ ಎಂದು ನಾನು ವಾದಿಸುತ್ತೇನೆ. ಈ ಪ್ರತಿಯೊಂದು ಸಮಸ್ಯೆಗಳಿಗೆ ನಾವು ಆಳವಾಗಿ ಧುಮುಕುವುದಿಲ್ಲ, ಆದರೆ ಅವುಗಳನ್ನು ಮೇಲ್ನೋಟಕ್ಕೆ ನೋಡುತ್ತೇವೆ.
ಹೆಚ್ಚಿನ ಕಾರ್ಡಿನಾಲಿಟಿ ಸಮಸ್ಯೆ
ಆದ್ದರಿಂದ, ಬಿಟ್ಮ್ಯಾಪ್ ಸೂಚ್ಯಂಕಗಳು ಕಡಿಮೆ ಕಾರ್ಡಿನಾಲಿಟಿ ಹೊಂದಿರುವ ಕ್ಷೇತ್ರಗಳಿಗೆ ಮಾತ್ರ ಸೂಕ್ತವೆಂದು ನಮಗೆ ಹೇಳಲಾಗುತ್ತದೆ, ಅಂದರೆ, ಕೆಲವು ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರುವ (ಉದಾಹರಣೆಗೆ, ಲಿಂಗ ಅಥವಾ ಕಣ್ಣಿನ ಬಣ್ಣ), ಮತ್ತು ಕಾರಣವೆಂದರೆ ಅಂತಹ ಕ್ಷೇತ್ರಗಳ ಸಾಮಾನ್ಯ ಪ್ರಾತಿನಿಧ್ಯ (ಒಂದು ಪ್ರತಿ ಮೌಲ್ಯಕ್ಕೆ ಬಿಟ್) ಹೆಚ್ಚಿನ ಕಾರ್ಡಿನಾಲಿಟಿಯ ಸಂದರ್ಭದಲ್ಲಿ, ಇದು ಹೆಚ್ಚು ಜಾಗವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಮೇಲಾಗಿ, ಈ ಬಿಟ್ಮ್ಯಾಪ್ ಸೂಚ್ಯಂಕಗಳು ಕಳಪೆಯಾಗಿ (ವಿರಳವಾಗಿ) ತುಂಬಿರುತ್ತವೆ.
ಕೆಲವೊಮ್ಮೆ ನಾವು ಸಂಖ್ಯೆಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಬಳಸುವ ಪ್ರಮಾಣಿತದಂತಹ ವಿಭಿನ್ನ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ಬಳಸಬಹುದು. ಆದರೆ ಕಂಪ್ರೆಷನ್ ಅಲ್ಗಾರಿದಮ್‌ಗಳ ಆಗಮನವು ಎಲ್ಲವನ್ನೂ ಬದಲಾಯಿಸಿತು. ಕಳೆದ ದಶಕಗಳಲ್ಲಿ, ವಿಜ್ಞಾನಿಗಳು ಮತ್ತು ಸಂಶೋಧಕರು ಬಿಟ್‌ಮ್ಯಾಪ್‌ಗಳಿಗಾಗಿ ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ಕಂಪ್ರೆಷನ್ ಅಲ್ಗಾರಿದಮ್‌ಗಳೊಂದಿಗೆ ಬಂದಿದ್ದಾರೆ. ಬಿಟ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಬಿಟ್ಮ್ಯಾಪ್ಗಳನ್ನು ಡಿಕಂಪ್ರೆಸ್ ಮಾಡುವ ಅಗತ್ಯವಿಲ್ಲ ಎಂಬುದು ಅವರ ಮುಖ್ಯ ಪ್ರಯೋಜನವಾಗಿದೆ - ನಾವು ನೇರವಾಗಿ ಸಂಕುಚಿತ ಬಿಟ್ಮ್ಯಾಪ್ಗಳಲ್ಲಿ ಬಿಟ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಮಾಡಬಹುದು.
ಇತ್ತೀಚೆಗೆ, ರೋರಿಂಗ್ ಬಿಟ್‌ಮ್ಯಾಪ್‌ಗಳಂತಹ ಹೈಬ್ರಿಡ್ ವಿಧಾನಗಳು ಕಾಣಿಸಿಕೊಳ್ಳಲು ಪ್ರಾರಂಭಿಸಿವೆ. ಅವರು ಏಕಕಾಲದಲ್ಲಿ ಬಿಟ್‌ಮ್ಯಾಪ್‌ಗಳಿಗಾಗಿ ಮೂರು ವಿಭಿನ್ನ ಪ್ರಾತಿನಿಧ್ಯಗಳನ್ನು ಬಳಸುತ್ತಾರೆ - ಬಿಟ್‌ಮ್ಯಾಪ್‌ಗಳು, ಅರೇಗಳು ಮತ್ತು ಬಿಟ್ ರನ್‌ಗಳು ಎಂದು ಕರೆಯಲ್ಪಡುತ್ತವೆ - ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಹೆಚ್ಚಿಸಲು ಮತ್ತು ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಅವುಗಳ ನಡುವೆ ಸಮತೋಲನ.
ಅತ್ಯಂತ ಜನಪ್ರಿಯ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ನೀವು ರೋರಿಂಗ್ ಬಿಟ್ಮ್ಯಾಪ್ಗಳನ್ನು ಕಾಣಬಹುದು. Go ಗಾಗಿ ಮೂರಕ್ಕಿಂತ ಹೆಚ್ಚು ಅನುಷ್ಠಾನಗಳನ್ನು ಒಳಗೊಂಡಂತೆ ವಿವಿಧ ರೀತಿಯ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಿಗೆ ಈಗಾಗಲೇ ಬೃಹತ್ ಸಂಖ್ಯೆಯ ಅನುಷ್ಠಾನಗಳಿವೆ.
ಹೆಚ್ಚಿನ ಕಾರ್ಡಿನಾಲಿಟಿಯನ್ನು ಎದುರಿಸಲು ನಮಗೆ ಸಹಾಯ ಮಾಡುವ ಇನ್ನೊಂದು ವಿಧಾನವನ್ನು ಬಿನ್ನಿಂಗ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಒಬ್ಬ ವ್ಯಕ್ತಿಯ ಎತ್ತರವನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಕ್ಷೇತ್ರವನ್ನು ನೀವು ಹೊಂದಿದ್ದೀರಿ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ಎತ್ತರವು ಒಂದು ಫ್ಲೋಟಿಂಗ್ ಪಾಯಿಂಟ್ ಸಂಖ್ಯೆ, ಆದರೆ ನಾವು ಮಾನವರು ಅದನ್ನು ಆ ರೀತಿಯಲ್ಲಿ ಯೋಚಿಸುವುದಿಲ್ಲ. ನಮಗೆ ಎತ್ತರ 185,2 ಸೆಂ ಮತ್ತು 185,3 ಸೆಂ ನಡುವೆ ಯಾವುದೇ ವ್ಯತ್ಯಾಸವಿಲ್ಲ.
ನಾವು ಒಂದೇ ರೀತಿಯ ಮೌಲ್ಯಗಳನ್ನು 1 cm ಒಳಗೆ ಗುಂಪುಗಳಾಗಿ ಗುಂಪು ಮಾಡಬಹುದು ಎಂದು ಅದು ತಿರುಗುತ್ತದೆ.
ಮತ್ತು ಕೆಲವೇ ಜನರು 50 ಸೆಂ.ಮೀ ಗಿಂತ ಕಡಿಮೆ ಮತ್ತು 250 ಸೆಂ.ಮೀ ಗಿಂತ ಕಡಿಮೆ ಇದ್ದಾರೆ ಎಂದು ನಮಗೆ ತಿಳಿದಿದ್ದರೆ, ನಾವು ಮೂಲಭೂತವಾಗಿ ಅನಂತ ಕಾರ್ಡಿನಾಲಿಟಿ ಹೊಂದಿರುವ ಕ್ಷೇತ್ರವನ್ನು ಸುಮಾರು 200 ಮೌಲ್ಯಗಳ ಕಾರ್ಡಿನಾಲಿಟಿ ಹೊಂದಿರುವ ಕ್ಷೇತ್ರವಾಗಿ ಪರಿವರ್ತಿಸಬಹುದು.
ಸಹಜವಾಗಿ, ಅಗತ್ಯವಿದ್ದರೆ, ನಾವು ನಂತರ ಹೆಚ್ಚುವರಿ ಫಿಲ್ಟರಿಂಗ್ ಮಾಡಬಹುದು.
ಹೆಚ್ಚಿನ ಬ್ಯಾಂಡ್‌ವಿಡ್ತ್ ಸಮಸ್ಯೆ
ಬಿಟ್ಮ್ಯಾಪ್ ಇಂಡೆಕ್ಸ್‌ಗಳೊಂದಿಗಿನ ಮುಂದಿನ ಸಮಸ್ಯೆಯೆಂದರೆ ಅವುಗಳನ್ನು ನವೀಕರಿಸುವುದು ತುಂಬಾ ದುಬಾರಿಯಾಗಿದೆ.
ನೂರಾರು ಇತರ ಪ್ರಶ್ನೆಗಳು ಡೇಟಾವನ್ನು ಹುಡುಕುತ್ತಿರುವಾಗ ಡೇಟಾಬೇಸ್‌ಗಳು ಡೇಟಾವನ್ನು ನವೀಕರಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ. ಏಕಕಾಲೀನ ಡೇಟಾ ಪ್ರವೇಶ ಅಥವಾ ಇತರ ಹಂಚಿಕೆ ಸಮಸ್ಯೆಗಳೊಂದಿಗೆ ಸಮಸ್ಯೆಗಳನ್ನು ತಪ್ಪಿಸಲು ನಮಗೆ ಲಾಕ್‌ಗಳ ಅಗತ್ಯವಿದೆ. ಮತ್ತು ಒಂದು ದೊಡ್ಡ ಲಾಕ್ ಇರುವಲ್ಲಿ, ಸಮಸ್ಯೆ ಇದೆ - ಲಾಕ್ ವಿವಾದ, ಈ ಲಾಕ್ ಅಡಚಣೆಯಾದಾಗ.
ಈ ಸಮಸ್ಯೆಯನ್ನು ಶಾರ್ಡಿಂಗ್ ಅಥವಾ ಆವೃತ್ತಿಯ ಸೂಚಿಕೆಗಳನ್ನು ಬಳಸುವ ಮೂಲಕ ಪರಿಹರಿಸಬಹುದು ಅಥವಾ ತಪ್ಪಿಸಬಹುದು.
ಶಾರ್ಡಿಂಗ್ ಸರಳ ಮತ್ತು ಪ್ರಸಿದ್ಧ ವಿಷಯವಾಗಿದೆ. ನೀವು ಯಾವುದೇ ಇತರ ಡೇಟಾದಂತೆ ಬಿಟ್ಮ್ಯಾಪ್ ಸೂಚ್ಯಂಕವನ್ನು ಹಂಚಿಕೊಳ್ಳಬಹುದು. ಒಂದು ದೊಡ್ಡ ಬೀಗದ ಬದಲಿಗೆ, ನೀವು ಸಣ್ಣ ಬೀಗಗಳ ಗುಂಪನ್ನು ಪಡೆಯುತ್ತೀರಿ ಮತ್ತು ಹೀಗಾಗಿ ಲಾಕ್ ವಿವಾದವನ್ನು ತೊಡೆದುಹಾಕುತ್ತೀರಿ.
ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಎರಡನೆಯ ಮಾರ್ಗವೆಂದರೆ ಆವೃತ್ತಿಯ ಸೂಚಿಕೆಗಳನ್ನು ಬಳಸುವುದು. ನೀವು ಹುಡುಕಲು ಅಥವಾ ಓದಲು ಬಳಸುವ ಸೂಚ್ಯಂಕದ ಒಂದು ನಕಲನ್ನು ನೀವು ಹೊಂದಬಹುದು ಮತ್ತು ಬರೆಯಲು ಅಥವಾ ನವೀಕರಿಸಲು ನೀವು ಬಳಸುವ ಒಂದನ್ನು ನೀವು ಹೊಂದಬಹುದು. ಮತ್ತು ಒಂದು ನಿರ್ದಿಷ್ಟ ಅವಧಿಯಲ್ಲಿ ಒಮ್ಮೆ (ಉದಾಹರಣೆಗೆ, ಒಮ್ಮೆ ಪ್ರತಿ 100 ms ಅಥವಾ 500 ms) ನೀವು ಅವುಗಳನ್ನು ನಕಲು ಮಾಡಿ ಮತ್ತು ಅವುಗಳನ್ನು ವಿನಿಮಯ ಮಾಡಿಕೊಳ್ಳಿ. ಸಹಜವಾಗಿ, ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಸ್ವಲ್ಪ ಹಿಂದುಳಿದ ಹುಡುಕಾಟ ಸೂಚ್ಯಂಕವನ್ನು ನಿಭಾಯಿಸಬಹುದಾದ ಸಂದರ್ಭಗಳಲ್ಲಿ ಮಾತ್ರ ಈ ವಿಧಾನವು ಅನ್ವಯಿಸುತ್ತದೆ.
ಈ ಎರಡು ವಿಧಾನಗಳನ್ನು ಏಕಕಾಲದಲ್ಲಿ ಬಳಸಬಹುದು: ನೀವು ಚೂರುಚೂರು ಆವೃತ್ತಿಯ ಸೂಚ್ಯಂಕವನ್ನು ಹೊಂದಬಹುದು.
ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಪ್ರಶ್ನೆಗಳು
ಬಿಟ್ಮ್ಯಾಪ್ ಇಂಡೆಕ್ಸ್‌ಗಳೊಂದಿಗಿನ ಅಂತಿಮ ಸಮಸ್ಯೆಯೆಂದರೆ, ಸ್ಪ್ಯಾನ್ ಪ್ರಶ್ನೆಗಳಂತಹ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಪ್ರಶ್ನೆಗಳಿಗೆ ಅವು ಸೂಕ್ತವಲ್ಲ ಎಂದು ನಮಗೆ ತಿಳಿಸಲಾಗಿದೆ.
ವಾಸ್ತವವಾಗಿ, ನೀವು ಅದರ ಬಗ್ಗೆ ಯೋಚಿಸಿದರೆ, AND, OR, ಇತ್ಯಾದಿ ಬಿಟ್ ಕಾರ್ಯಾಚರಣೆಗಳು "ಪ್ರತಿ ರಾತ್ರಿ 200 ಮತ್ತು 300 ಡಾಲರ್ಗಳ ನಡುವಿನ ಕೊಠಡಿ ದರಗಳೊಂದಿಗೆ ಹೋಟೆಲ್‌ಗಳನ್ನು ನನಗೆ ತೋರಿಸು" ಎಂಬ ಪ್ರಶ್ನೆಗಳಿಗೆ ತುಂಬಾ ಸೂಕ್ತವಲ್ಲ.
ಪ್ರತಿ ಡಾಲರ್ ಮೌಲ್ಯಕ್ಕೆ ಫಲಿತಾಂಶಗಳನ್ನು ತೆಗೆದುಕೊಂಡು ಅವುಗಳನ್ನು ಬಿಟ್‌ವೈಸ್ ಅಥವಾ ಕಾರ್ಯಾಚರಣೆಯೊಂದಿಗೆ ಸಂಯೋಜಿಸುವುದು ನಿಷ್ಕಪಟ ಮತ್ತು ಅತ್ಯಂತ ಅವಿವೇಕದ ಪರಿಹಾರವಾಗಿದೆ.
ಗುಂಪನ್ನು ಬಳಸುವುದು ಸ್ವಲ್ಪ ಉತ್ತಮ ಪರಿಹಾರವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, 50 ಡಾಲರ್ಗಳ ಗುಂಪುಗಳಲ್ಲಿ. ಇದು ನಮ್ಮ ಪ್ರಕ್ರಿಯೆಯನ್ನು 50 ಪಟ್ಟು ವೇಗಗೊಳಿಸುತ್ತದೆ.
ಆದರೆ ಈ ರೀತಿಯ ವಿನಂತಿಗಾಗಿ ನಿರ್ದಿಷ್ಟವಾಗಿ ರಚಿಸಲಾದ ವೀಕ್ಷಣೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಸಮಸ್ಯೆಯನ್ನು ಸುಲಭವಾಗಿ ಪರಿಹರಿಸಲಾಗುತ್ತದೆ. ವೈಜ್ಞಾನಿಕ ಪತ್ರಿಕೆಗಳಲ್ಲಿ ಇದನ್ನು ಶ್ರೇಣಿ-ಎನ್‌ಕೋಡ್ ಮಾಡಿದ ಬಿಟ್‌ಮ್ಯಾಪ್‌ಗಳು ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.
ಈ ಪ್ರಾತಿನಿಧ್ಯದಲ್ಲಿ, ನಾವು ಕೆಲವು ಮೌಲ್ಯಗಳಿಗೆ ಒಂದು ಬಿಟ್ ಅನ್ನು ಹೊಂದಿಸುವುದಿಲ್ಲ (ಉದಾಹರಣೆಗೆ, 200), ಆದರೆ ಈ ಮೌಲ್ಯ ಮತ್ತು ಎಲ್ಲವನ್ನೂ ಹೆಚ್ಚು ಹೊಂದಿಸಿ. 200 ಮತ್ತು ಹೆಚ್ಚಿನದು. 300: 300 ಮತ್ತು ಅದಕ್ಕಿಂತ ಹೆಚ್ಚಿನವರಿಗೆ ಒಂದೇ. ಮತ್ತು ಇತ್ಯಾದಿ.
ಈ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು, ನಾವು ಕೇವಲ ಎರಡು ಬಾರಿ ಸೂಚ್ಯಂಕವನ್ನು ಹಾದುಹೋಗುವ ಮೂಲಕ ಈ ರೀತಿಯ ಹುಡುಕಾಟ ಪ್ರಶ್ನೆಗೆ ಉತ್ತರಿಸಬಹುದು. ಮೊದಲಿಗೆ, ಕೊಠಡಿಯ ಬೆಲೆ ಕಡಿಮೆ ಅಥವಾ $300 ಇರುವ ಹೋಟೆಲ್‌ಗಳ ಪಟ್ಟಿಯನ್ನು ನಾವು ಪಡೆಯುತ್ತೇವೆ ಮತ್ತು ನಂತರ ನಾವು ಕೊಠಡಿಯ ಬೆಲೆ ಕಡಿಮೆ ಅಥವಾ $199 ಇರುವ ಹೋಟೆಲ್‌ಗಳನ್ನು ತೆಗೆದುಹಾಕುತ್ತೇವೆ. ಸಿದ್ಧವಾಗಿದೆ.
ನಿಮಗೆ ಆಶ್ಚರ್ಯವಾಗುತ್ತದೆ, ಆದರೆ ಬಿಟ್ಮ್ಯಾಪ್ ಇಂಡೆಕ್ಸ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಜಿಯೋಕ್ವೆರಿಗಳು ಸಹ ಸಾಧ್ಯವಿದೆ. ಜ್ಯಾಮಿತೀಯ ಫಿಗರ್‌ನೊಂದಿಗೆ ನಿಮ್ಮ ನಿರ್ದೇಶಾಂಕವನ್ನು ಸುತ್ತುವರೆದಿರುವ ಜ್ಯಾಮಿತೀಯ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ಬಳಸುವುದು ಟ್ರಿಕ್ ಆಗಿದೆ. ಉದಾಹರಣೆಗೆ, Google ನಿಂದ S2. ಆಕೃತಿಯು ಮೂರು ಅಥವಾ ಅದಕ್ಕಿಂತ ಹೆಚ್ಚು ಛೇದಿಸುವ ರೇಖೆಗಳ ರೂಪದಲ್ಲಿ ಪ್ರತಿನಿಧಿಸಲು ಸಾಧ್ಯವಾಗಬೇಕು, ಅದನ್ನು ಸಂಖ್ಯೆ ಮಾಡಬಹುದಾಗಿದೆ. ಈ ರೀತಿಯಲ್ಲಿ ನಾವು ನಮ್ಮ ಜಿಯೋಕ್ವೆರಿಯನ್ನು "ಅಂತರದಲ್ಲಿ" (ಈ ಸಂಖ್ಯೆಯ ರೇಖೆಗಳ ಉದ್ದಕ್ಕೂ) ಹಲವಾರು ಪ್ರಶ್ನೆಗಳಾಗಿ ಪರಿವರ್ತಿಸಬಹುದು.
ಸಿದ್ಧ ಪರಿಹಾರಗಳು
ನಾನು ನಿಮಗೆ ಸ್ವಲ್ಪ ಆಸಕ್ತಿಯನ್ನು ಹೊಂದಿದ್ದೇನೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ ಮತ್ತು ಈಗ ನಿಮ್ಮ ಆರ್ಸೆನಲ್‌ನಲ್ಲಿ ನೀವು ಇನ್ನೊಂದು ಉಪಯುಕ್ತ ಸಾಧನವನ್ನು ಹೊಂದಿದ್ದೀರಿ. ನೀವು ಎಂದಾದರೂ ಈ ರೀತಿಯ ಏನನ್ನಾದರೂ ಮಾಡಬೇಕಾದರೆ, ಯಾವ ರೀತಿಯಲ್ಲಿ ನೋಡಬೇಕೆಂದು ನಿಮಗೆ ತಿಳಿಯುತ್ತದೆ.
ಆದಾಗ್ಯೂ, ಬಿಟ್ಮ್ಯಾಪ್ ಇಂಡೆಕ್ಸ್‌ಗಳನ್ನು ಮೊದಲಿನಿಂದಲೂ ರಚಿಸಲು ಎಲ್ಲರಿಗೂ ಸಮಯ, ತಾಳ್ಮೆ ಅಥವಾ ಸಂಪನ್ಮೂಲಗಳಿಲ್ಲ. ವಿಶೇಷವಾಗಿ ಹೆಚ್ಚು ಮುಂದುವರಿದವುಗಳು, ಉದಾಹರಣೆಗೆ SIMD ಬಳಸಿ.
ಅದೃಷ್ಟವಶಾತ್, ನಿಮಗೆ ಸಹಾಯ ಮಾಡಲು ಹಲವಾರು ಸಿದ್ಧ ಪರಿಹಾರಗಳಿವೆ.
ರೋರಿಂಗ್ ಬಿಟ್‌ಮ್ಯಾಪ್‌ಗಳು
ಮೊದಲನೆಯದಾಗಿ, ನಾನು ಈಗಾಗಲೇ ಮಾತನಾಡಿರುವ ಅದೇ ರೋರಿಂಗ್ ಬಿಟ್‌ಮ್ಯಾಪ್‌ಗಳ ಲೈಬ್ರರಿ ಇದೆ. ನೀವು ಪೂರ್ಣ ಪ್ರಮಾಣದ ಬಿಟ್ಮ್ಯಾಪ್ ಸೂಚ್ಯಂಕವನ್ನು ಮಾಡಬೇಕಾದ ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ಕಂಟೇನರ್‌ಗಳು ಮತ್ತು ಬಿಟ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಇದು ಒಳಗೊಂಡಿದೆ.
ದುರದೃಷ್ಟವಶಾತ್, ಈ ಸಮಯದಲ್ಲಿ, ಯಾವುದೇ Go ಅಳವಡಿಕೆಗಳು SIMD ಅನ್ನು ಬಳಸುವುದಿಲ್ಲ, ಅಂದರೆ Go ಅನುಷ್ಠಾನಗಳು C ಅಳವಡಿಕೆಗಳಿಗಿಂತ ಕಡಿಮೆ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಹೊಂದಿವೆ, ಉದಾಹರಣೆಗೆ.
ಪಿಲೋಸಾ
ನಿಮಗೆ ಸಹಾಯ ಮಾಡುವ ಮತ್ತೊಂದು ಉತ್ಪನ್ನವೆಂದರೆ ಪಿಲೋಸಾ ಡಿಬಿಎಂಎಸ್, ಇದು ವಾಸ್ತವವಾಗಿ ಬಿಟ್ಮ್ಯಾಪ್ ಸೂಚ್ಯಂಕಗಳನ್ನು ಮಾತ್ರ ಹೊಂದಿದೆ. ಇದು ತುಲನಾತ್ಮಕವಾಗಿ ಹೊಸ ಪರಿಹಾರವಾಗಿದೆ, ಆದರೆ ಇದು ಹೆಚ್ಚಿನ ವೇಗದಲ್ಲಿ ಹೃದಯಗಳನ್ನು ಗೆಲ್ಲುತ್ತಿದೆ.
Pilosa ಆಂತರಿಕವಾಗಿ ರೋರಿಂಗ್ ಬಿಟ್ಮ್ಯಾಪ್ಗಳನ್ನು ಬಳಸುತ್ತದೆ ಮತ್ತು ಅವುಗಳನ್ನು ಬಳಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ನಿಮಗೆ ನೀಡುತ್ತದೆ, ನಾನು ಮೇಲೆ ಮಾತನಾಡಿದ ಎಲ್ಲಾ ವಿಷಯಗಳನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ವಿವರಿಸುತ್ತದೆ: ಗುಂಪು ಮಾಡುವುದು, ಶ್ರೇಣಿ-ಎನ್‌ಕೋಡ್ ಮಾಡಿದ ಬಿಟ್‌ಮ್ಯಾಪ್‌ಗಳು, ಕ್ಷೇತ್ರದ ಪರಿಕಲ್ಪನೆ, ಇತ್ಯಾದಿ.
ನೀವು ಈಗಾಗಲೇ ಪರಿಚಿತವಾಗಿರುವ ಪ್ರಶ್ನೆಗೆ ಉತ್ತರಿಸಲು Pilosa ಅನ್ನು ಬಳಸುವ ಉದಾಹರಣೆಯನ್ನು ತ್ವರಿತವಾಗಿ ನೋಡೋಣ.
ಉದಾಹರಣೆಯು ನೀವು ಮೊದಲು ನೋಡಿದಂತೆಯೇ ಇದೆ. ನಾವು ಪಿಲೋಸಾ ಸರ್ವರ್‌ಗೆ ಕ್ಲೈಂಟ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ, ಸೂಚ್ಯಂಕ ಮತ್ತು ಅಗತ್ಯ ಕ್ಷೇತ್ರಗಳನ್ನು ರಚಿಸುತ್ತೇವೆ, ನಂತರ ನಮ್ಮ ಕ್ಷೇತ್ರಗಳನ್ನು ಸಂಭವನೀಯತೆಗಳೊಂದಿಗೆ ಯಾದೃಚ್ಛಿಕ ಡೇಟಾದೊಂದಿಗೆ ತುಂಬುತ್ತೇವೆ ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಪರಿಚಿತ ಪ್ರಶ್ನೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತೇವೆ.
ಅದರ ನಂತರ, ನಾವು "ದುಬಾರಿ" ಕ್ಷೇತ್ರದಲ್ಲಿ NOT ಅನ್ನು ಬಳಸುತ್ತೇವೆ, ನಂತರ ಫಲಿತಾಂಶವನ್ನು (ಅಥವಾ ಮತ್ತು ಅದು) "ಟೆರೇಸ್" ಕ್ಷೇತ್ರದೊಂದಿಗೆ ಮತ್ತು "ಮೀಸಲಾತಿ" ಕ್ಷೇತ್ರದೊಂದಿಗೆ ಛೇದಿಸಿ. ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನಾವು ಅಂತಿಮ ಫಲಿತಾಂಶವನ್ನು ಪಡೆಯುತ್ತೇವೆ.
ನಿರೀಕ್ಷಿತ ಭವಿಷ್ಯದಲ್ಲಿ ಈ ಹೊಸ ಪ್ರಕಾರದ ಸೂಚ್ಯಂಕವು MySQL ಮತ್ತು PostgreSQL - ಬಿಟ್ಮ್ಯಾಪ್ ಇಂಡೆಕ್ಸ್‌ಗಳಂತಹ DBMS ಗಳಲ್ಲಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ ಎಂದು ನಾನು ನಿಜವಾಗಿಯೂ ಭಾವಿಸುತ್ತೇನೆ.
ತೀರ್ಮಾನಕ್ಕೆ
ನೀವು ಇನ್ನೂ ನಿದ್ದೆ ಮಾಡದಿದ್ದರೆ, ಧನ್ಯವಾದಗಳು. ಸೀಮಿತ ಸಮಯದ ಕಾರಣದಿಂದಾಗಿ ನಾನು ಅನೇಕ ವಿಷಯಗಳ ಮೇಲೆ ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಸ್ಪರ್ಶಿಸಬೇಕಾಗಿತ್ತು, ಆದರೆ ಭಾಷಣವು ಉಪಯುಕ್ತವಾಗಿದೆ ಮತ್ತು ಬಹುಶಃ ಪ್ರೇರೇಪಿಸುತ್ತದೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ.
ಬಿಟ್ಮ್ಯಾಪ್ ಇಂಡೆಕ್ಸ್‌ಗಳು ನಿಮಗೆ ಇದೀಗ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದರೂ ಸಹ, ಅವುಗಳ ಬಗ್ಗೆ ತಿಳಿದುಕೊಳ್ಳುವುದು ಒಳ್ಳೆಯದು. ನಿಮ್ಮ ಟೂಲ್‌ಬಾಕ್ಸ್‌ನಲ್ಲಿ ಅವು ಮತ್ತೊಂದು ಸಾಧನವಾಗಿರಲಿ.
ನಾವು Go ಗಾಗಿ ವಿವಿಧ ಕಾರ್ಯಕ್ಷಮತೆಯ ತಂತ್ರಗಳನ್ನು ಮತ್ತು Go ಕಂಪೈಲರ್ ಇನ್ನೂ ಉತ್ತಮವಾಗಿ ನಿರ್ವಹಿಸದ ವಿಷಯಗಳನ್ನು ನೋಡಿದ್ದೇವೆ. ಆದರೆ ಪ್ರತಿಯೊಬ್ಬ ಗೋ ಪ್ರೋಗ್ರಾಮರ್ ತಿಳಿದುಕೊಳ್ಳಲು ಇದು ಸಂಪೂರ್ಣವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ.
ನಾನು ನಿಮಗೆ ಹೇಳಲು ಬಯಸಿದ್ದೆ ಅಷ್ಟೆ. ಧನ್ಯವಾದ!
ಮೂಲ: www.habr.com