ಲಾಕ್-ಫ್ರೀ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು: ಜಾಗತಿಕ ಡೆವಲಪರ್‌ಗಳಿಗಾಗಿ ಅಟಾಮಿಕ್ ಆಪರೇಷನ್‌ಗಳ ಶಕ್ತಿ

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

ಲಾಕ್-ಫ್ರೀ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಎಂದರೇನು?

ಲಾಕ್-ಫ್ರೀ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಒಂದು ಕನ್ಕರೆನ್ಸಿ ನಿಯಂತ್ರಣ ತಂತ್ರವಾಗಿದ್ದು, ಇದು ಸಿಸ್ಟಮ್-ವೈಡ್ ಪ್ರಗತಿಯನ್ನು ಖಾತರಿಪಡಿಸುತ್ತದೆ. ಲಾಕ್-ಫ್ರೀ ಸಿಸ್ಟಮ್‌ನಲ್ಲಿ, ಇತರ ಥ್ರೆಡ್‌ಗಳು ವಿಳಂಬವಾದರೂ ಅಥವಾ ಅಮಾನತುಗೊಂಡರೂ ಕನಿಷ್ಠ ಒಂದು ಥ್ರೆಡ್ ಯಾವಾಗಲೂ ಪ್ರಗತಿ ಸಾಧಿಸುತ್ತದೆ. ಇದು ಲಾಕ್-ಆಧಾರಿತ ವ್ಯವಸ್ಥೆಗಳಿಗೆ ವ್ಯತಿರಿಕ್ತವಾಗಿದೆ, ಅಲ್ಲಿ ಲಾಕ್ ಅನ್ನು ಹಿಡಿದಿರುವ ಥ್ರೆಡ್ ಅಮಾನತುಗೊಳ್ಳಬಹುದು, ಆ ಲಾಕ್ ಅಗತ್ಯವಿರುವ ಯಾವುದೇ ಇತರ ಥ್ರೆಡ್ ಮುಂದುವರಿಯದಂತೆ ತಡೆಯುತ್ತದೆ. ಇದು ಡೆಡ್‌ಲಾಕ್‌ಗಳು ಅಥವಾ ಲೈವ್‌ಲಾಕ್‌ಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು, ಇದು ಅಪ್ಲಿಕೇಶನ್‌ನ ಸ್ಪಂದನಾಶೀಲತೆಯನ್ನು ತೀವ್ರವಾಗಿ ಬಾಧಿಸುತ್ತದೆ.

ಲಾಕ್-ಫ್ರೀ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನ ಪ್ರಾಥಮಿಕ ಗುರಿಯು ಸಾಂಪ್ರದಾಯಿಕ ಲಾಕಿಂಗ್ ಕಾರ್ಯವಿಧಾನಗಳಿಗೆ ಸಂಬಂಧಿಸಿದ ಸ್ಪರ್ಧೆ ಮತ್ತು ಸಂಭಾವ್ಯ ಬ್ಲಾಕಿಂಗ್ ಅನ್ನು ತಪ್ಪಿಸುವುದಾಗಿದೆ. ಹಂಚಿದ ಡೇಟಾದ ಮೇಲೆ ಸ್ಪಷ್ಟವಾದ ಲಾಕ್‌ಗಳಿಲ್ಲದೆ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಅಲ್ಗಾರಿದಮ್‌ಗಳನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ವಿನ್ಯಾಸಗೊಳಿಸುವ ಮೂಲಕ, ಡೆವಲಪರ್‌ಗಳು ಇದನ್ನು ಸಾಧಿಸಬಹುದು:

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

ಮೂಲೆಗಲ್ಲು: ಅಟಾಮಿಕ್ ಆಪರೇಷನ್ಸ್

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

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

ಸಾಮಾನ್ಯ ಅಟಾಮಿಕ್ ಆಪರೇಷನ್‌ಗಳು

ಹಾರ್ಡ್‌ವೇರ್ ಆರ್ಕಿಟೆಕ್ಚರ್‌ಗಳು ಮತ್ತು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ ಅಟಾಮಿಕ್ ಆಪರೇಷನ್‌ಗಳ ನಿರ್ದಿಷ್ಟ ಸೆಟ್ ಬದಲಾಗಬಹುದಾದರೂ, ಕೆಲವು ಮೂಲಭೂತ ಕಾರ್ಯಾಚರಣೆಗಳು ವ್ಯಾಪಕವಾಗಿ ಬೆಂಬಲಿತವಾಗಿದೆ:

• ಅಟಾಮಿಕ್ ರೀಡ್: ಮೆಮೊರಿಯಿಂದ ಮೌಲ್ಯವನ್ನು ಒಂದೇ, ಅಡ್ಡಿಪಡಿಸಲಾಗದ ಕಾರ್ಯಾಚರಣೆಯಾಗಿ ಓದುತ್ತದೆ.
• ಅಟಾಮಿಕ್ ರೈಟ್: ಮೆಮೊರಿಗೆ ಮೌಲ್ಯವನ್ನು ಒಂದೇ, ಅಡ್ಡಿಪಡಿಸಲಾಗದ ಕಾರ್ಯಾಚರಣೆಯಾಗಿ ಬರೆಯುತ್ತದೆ.
• ಫೆಚ್-ಅಂಡ್-ಆಡ್ (FAA): ಮೆಮೊರಿ ಸ್ಥಳದಿಂದ ಮೌಲ್ಯವನ್ನು ಅಟಾಮಿಕ್ ಆಗಿ ಓದುತ್ತದೆ, ಅದಕ್ಕೆ ನಿರ್ದಿಷ್ಟ ಮೊತ್ತವನ್ನು ಸೇರಿಸುತ್ತದೆ, ಮತ್ತು ಹೊಸ ಮೌಲ್ಯವನ್ನು ಮರಳಿ ಬರೆಯುತ್ತದೆ. ಇದು ಮೂಲ ಮೌಲ್ಯವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಅಟಾಮಿಕ್ ಕೌಂಟರ್‌ಗಳನ್ನು ರಚಿಸಲು ಇದು ನಂಬಲಾಗದಷ್ಟು ಉಪಯುಕ್ತವಾಗಿದೆ.
• ಕಂಪೇರ್-ಅಂಡ್-ಸ್ವಾಪ್ (CAS): ಇದು ಬಹುಶಃ ಲಾಕ್-ಫ್ರೀ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ಗೆ ಅತ್ಯಂತ ಪ್ರಮುಖವಾದ ಅಟಾಮಿಕ್ ಪ್ರಿಮಿಟಿವ್ ಆಗಿದೆ. CAS ಮೂರು ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ: ಮೆಮೊರಿ ಸ್ಥಳ, ನಿರೀಕ್ಷಿತ ಹಳೆಯ ಮೌಲ್ಯ, ಮತ್ತು ಹೊಸ ಮೌಲ್ಯ. ಇದು ಮೆಮೊರಿ ಸ್ಥಳದಲ್ಲಿನ ಮೌಲ್ಯವು ನಿರೀಕ್ಷಿತ ಹಳೆಯ ಮೌಲ್ಯಕ್ಕೆ ಸಮನಾಗಿದೆಯೇ ಎಂದು ಅಟಾಮಿಕ್ ಆಗಿ ಪರಿಶೀಲಿಸುತ್ತದೆ. ಹಾಗಿದ್ದಲ್ಲಿ, ಅದು ಮೆಮೊರಿ ಸ್ಥಳವನ್ನು ಹೊಸ ಮೌಲ್ಯದೊಂದಿಗೆ ನವೀಕರಿಸುತ್ತದೆ ಮತ್ತು ಟ್ರೂ (ಅಥವಾ ಹಳೆಯ ಮೌಲ್ಯ) ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಮೌಲ್ಯವು ನಿರೀಕ್ಷಿತ ಹಳೆಯ ಮೌಲ್ಯಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗದಿದ್ದರೆ, ಅದು ಏನನ್ನೂ ಮಾಡುವುದಿಲ್ಲ ಮತ್ತು ಫಾಲ್ಸ್ (ಅಥವಾ ಪ್ರಸ್ತುತ ಮೌಲ್ಯ) ಹಿಂದಿರುಗಿಸುತ್ತದೆ.
• ಫೆಚ್-ಅಂಡ್-ಆರ್, ಫೆಚ್-ಅಂಡ್-ಆಂಡ್, ಫೆಚ್-ಅಂಡ್-XOR: FAA ಯಂತೆಯೇ, ಈ ಕಾರ್ಯಾಚರಣೆಗಳು ಮೆಮೊರಿ ಸ್ಥಳದಲ್ಲಿನ ಪ್ರಸ್ತುತ ಮೌಲ್ಯ ಮತ್ತು ನೀಡಿದ ಮೌಲ್ಯದ ನಡುವೆ ಬಿಟ್‌ವೈಸ್ ಕಾರ್ಯಾಚರಣೆಯನ್ನು (OR, AND, XOR) ನಿರ್ವಹಿಸುತ್ತವೆ, ಮತ್ತು ನಂತರ ಫಲಿತಾಂಶವನ್ನು ಮರಳಿ ಬರೆಯುತ್ತವೆ.

ಲಾಕ್-ಫ್ರೀಗೆ ಅಟಾಮಿಕ್ ಆಪರೇಷನ್‌ಗಳು ಏಕೆ ಅವಶ್ಯಕ?

ಲಾಕ್-ಫ್ರೀ ಅಲ್ಗಾರಿದಮ್‌ಗಳು ಸಾಂಪ್ರದಾಯಿಕ ಲಾಕ್‌ಗಳಿಲ್ಲದೆ ಹಂಚಿದ ಡೇಟಾವನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ನಿರ್ವಹಿಸಲು ಅಟಾಮಿಕ್ ಆಪರೇಷನ್‌ಗಳನ್ನು ಅವಲಂಬಿಸಿವೆ. ಕಂಪೇರ್-ಅಂಡ್-ಸ್ವಾಪ್ (CAS) ಕಾರ್ಯಾಚರಣೆಯು ವಿಶೇಷವಾಗಿ ಪ್ರಮುಖವಾಗಿದೆ. ಬಹು ಥ್ರೆಡ್‌ಗಳು ಹಂಚಿದ ಕೌಂಟರ್ ಅನ್ನು ನವೀಕರಿಸಬೇಕಾದ ಸನ್ನಿವೇಶವನ್ನು ಪರಿಗಣಿಸಿ. ಒಂದು ಸರಳ ವಿಧಾನವು ಕೌಂಟರ್ ಅನ್ನು ಓದುವುದು, ಅದನ್ನು ಹೆಚ್ಚಿಸುವುದು ಮತ್ತು ಅದನ್ನು ಮರಳಿ ಬರೆಯುವುದನ್ನು ಒಳಗೊಂಡಿರಬಹುದು. ಈ ಅನುಕ್ರಮವು ರೇಸ್ ಕಂಡೀಷನ್‌ಗಳಿಗೆ ಗುರಿಯಾಗುತ್ತದೆ:

// ಅಟಾಮಿಕ್-ಅಲ್ಲದ ಇನ್ಕ್ರಿಮೆಂಟ್ (ರೇಸ್ ಕಂಡೀಷನ್‌ಗಳಿಗೆ ಗುರಿಯಾಗಬಹುದು)
int counter = shared_variable;
counter++;
shared_variable = counter;

ಥ್ರೆಡ್ A ಮೌಲ್ಯ 5 ಅನ್ನು ಓದಿದರೆ, ಮತ್ತು ಅದು 6 ಅನ್ನು ಮರಳಿ ಬರೆಯುವ ಮೊದಲು, ಥ್ರೆಡ್ B ಸಹ 5 ಅನ್ನು ಓದುತ್ತದೆ, ಅದನ್ನು 6 ಕ್ಕೆ ಹೆಚ್ಚಿಸುತ್ತದೆ ಮತ್ತು 6 ಅನ್ನು ಮರಳಿ ಬರೆಯುತ್ತದೆ, ನಂತರ ಥ್ರೆಡ್ A 6 ಅನ್ನು ಮರಳಿ ಬರೆಯುತ್ತದೆ, ಥ್ರೆಡ್ B ಯ ನವೀಕರಣವನ್ನು ಓವರ್‌ರೈಟ್ ಮಾಡುತ್ತದೆ. ಕೌಂಟರ್ 7 ಆಗಿರಬೇಕು, ಆದರೆ ಅದು ಕೇವಲ 6 ಆಗಿದೆ.

CAS ಬಳಸಿ, ಕಾರ್ಯಾಚರಣೆಯು ಹೀಗಾಗುತ್ತದೆ:

// CAS ಬಳಸಿ ಅಟಾಮಿಕ್ ಇನ್ಕ್ರಿಮೆಂಟ್
int expected_value = shared_variable.load();
int new_value;

do {
    new_value = expected_value + 1;
} while (!shared_variable.compare_exchange_weak(expected_value, new_value));

ಈ CAS-ಆಧಾರಿತ ವಿಧಾನದಲ್ಲಿ:

1. ಥ್ರೆಡ್ ಪ್ರಸ್ತುತ ಮೌಲ್ಯವನ್ನು (`expected_value`) ಓದುತ್ತದೆ.
2. ಇದು `new_value` ಅನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತದೆ.
3. ಇದು `shared_variable` ನಲ್ಲಿನ ಮೌಲ್ಯವು ಇನ್ನೂ `expected_value` ಆಗಿದ್ದರೆ ಮಾತ್ರ `expected_value` ಅನ್ನು `new_value` ನೊಂದಿಗೆ ಸ್ವಾಪ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ.
4. ಸ್ವಾಪ್ ಯಶಸ್ವಿಯಾದರೆ, ಕಾರ್ಯಾಚರಣೆ ಪೂರ್ಣಗೊಳ್ಳುತ್ತದೆ.
5. ಸ್ವಾಪ್ ವಿಫಲವಾದರೆ (ಏಕೆಂದರೆ ಮತ್ತೊಂದು ಥ್ರೆಡ್ `shared_variable` ಅನ್ನು ಮಧ್ಯದಲ್ಲಿ ಮಾರ್ಪಡಿಸಿದೆ), `expected_value` ಅನ್ನು `shared_variable` ನ ಪ್ರಸ್ತುತ ಮೌಲ್ಯದೊಂದಿಗೆ ನವೀಕರಿಸಲಾಗುತ್ತದೆ, ಮತ್ತು ಲೂಪ್ CAS ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಪುನಃ ಪ್ರಯತ್ನಿಸುತ್ತದೆ.

ಈ ರಿಟ್ರೈ ಲೂಪ್ ಇನ್ಕ್ರಿಮೆಂಟ್ ಕಾರ್ಯಾಚರಣೆಯು ಅಂತಿಮವಾಗಿ ಯಶಸ್ವಿಯಾಗುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಲಾಕ್ ಇಲ್ಲದೆ ಪ್ರಗತಿಯನ್ನು ಖಾತರಿಪಡಿಸುತ್ತದೆ. `compare_exchange_weak` (C++ ನಲ್ಲಿ ಸಾಮಾನ್ಯ) ಬಳಕೆಯು ಒಂದೇ ಕಾರ್ಯಾಚರಣೆಯೊಳಗೆ ಅನೇಕ ಬಾರಿ ಪರಿಶೀಲನೆಯನ್ನು ಮಾಡಬಹುದು ಆದರೆ ಕೆಲವು ಆರ್ಕಿಟೆಕ್ಚರ್‌ಗಳಲ್ಲಿ ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿರಬಹುದು. ಒಂದೇ ಪಾಸ್‌ನಲ್ಲಿ ಸಂಪೂರ್ಣ ನಿಶ್ಚಿತತೆಗಾಗಿ, `compare_exchange_strong` ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.

ಲಾಕ್-ಫ್ರೀ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಸಾಧಿಸುವುದು

ನಿಜವಾಗಿಯೂ ಲಾಕ್-ಫ್ರೀ ಎಂದು ಪರಿಗಣಿಸಲು, ಒಂದು ಅಲ್ಗಾರಿದಮ್ ಈ ಕೆಳಗಿನ ಷರತ್ತನ್ನು ಪೂರೈಸಬೇಕು:

• ಖಾತರಿಯಾದ ಸಿಸ್ಟಮ್-ವೈಡ್ ಪ್ರಗತಿ: ಯಾವುದೇ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯಲ್ಲಿ, ಕನಿಷ್ಠ ಒಂದು ಥ್ರೆಡ್ ಸೀಮಿತ ಸಂಖ್ಯೆಯ ಹಂತಗಳಲ್ಲಿ ತನ್ನ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಪೂರ್ಣಗೊಳಿಸುತ್ತದೆ. ಇದರರ್ಥ ಕೆಲವು ಥ್ರೆಡ್‌ಗಳು ಹಸಿವಿನಿಂದ ಬಳಲುತ್ತಿದ್ದರೂ ಅಥವಾ ವಿಳಂಬವಾದರೂ, ಒಟ್ಟಾರೆಯಾಗಿ ಸಿಸ್ಟಮ್ ಪ್ರಗತಿ ಸಾಧಿಸುವುದನ್ನು ಮುಂದುವರಿಸುತ್ತದೆ.

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

ಲಾಕ್-ಫ್ರೀ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿನ ಸವಾಲುಗಳು

ಪ್ರಯೋಜನಗಳು ಗಣನೀಯವಾಗಿದ್ದರೂ, ಲಾಕ್-ಫ್ರೀ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಬೆಳ್ಳಿಯ ಗುಂಡು ಅಲ್ಲ ಮತ್ತು ತನ್ನದೇ ಆದ ಸವಾಲುಗಳೊಂದಿಗೆ ಬರುತ್ತದೆ:

1. ಸಂಕೀರ್ಣತೆ ಮತ್ತು ನಿಖರತೆ

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

2. ಎಬಿಎ ಸಮಸ್ಯೆ (ABA Problem)

ಎಬಿಎ ಸಮಸ್ಯೆಯು ಲಾಕ್-ಫ್ರೀ ಡೇಟಾ ರಚನೆಗಳಲ್ಲಿ, ವಿಶೇಷವಾಗಿ CAS ಬಳಸುವವುಗಳಲ್ಲಿ ಒಂದು ಕ್ಲಾಸಿಕ್ ಸವಾಲಾಗಿದೆ. ಒಂದು ಮೌಲ್ಯವನ್ನು ಓದಿದಾಗ (A), ನಂತರ ಮತ್ತೊಂದು ಥ್ರೆಡ್‌ನಿಂದ B ಗೆ ಮಾರ್ಪಡಿಸಿದಾಗ, ಮತ್ತು ನಂತರ ಮೊದಲ ಥ್ರೆಡ್ ತನ್ನ CAS ಕಾರ್ಯಾಚರಣೆಯನ್ನು ನಿರ್ವಹಿಸುವ ಮೊದಲು ಮತ್ತೆ A ಗೆ ಮಾರ್ಪಡಿಸಿದಾಗ ಇದು ಸಂಭವಿಸುತ್ತದೆ. CAS ಕಾರ್ಯಾಚರಣೆಯು ಯಶಸ್ವಿಯಾಗುತ್ತದೆ ಏಕೆಂದರೆ ಮೌಲ್ಯವು A ಆಗಿದೆ, ಆದರೆ ಮೊದಲ ಓದುವಿಕೆ ಮತ್ತು CAS ನಡುವಿನ ಡೇಟಾ ಗಮನಾರ್ಹ ಬದಲಾವಣೆಗಳಿಗೆ ಒಳಗಾಗಿರಬಹುದು, ಇದು ತಪ್ಪಾದ ನಡವಳಿಕೆಗೆ ಕಾರಣವಾಗುತ್ತದೆ.

ಉದಾಹರಣೆ:

1. ಥ್ರೆಡ್ 1 ಹಂಚಿದ ವೇರಿಯೇಬಲ್‌ನಿಂದ A ಮೌಲ್ಯವನ್ನು ಓದುತ್ತದೆ.
2. ಥ್ರೆಡ್ 2 ಮೌಲ್ಯವನ್ನು B ಗೆ ಬದಲಾಯಿಸುತ್ತದೆ.
3. ಥ್ರೆಡ್ 2 ಮೌಲ್ಯವನ್ನು ಮತ್ತೆ A ಗೆ ಬದಲಾಯಿಸುತ್ತದೆ.
4. ಥ್ರೆಡ್ 1 ಮೂಲ ಮೌಲ್ಯ A ಯೊಂದಿಗೆ CAS ಮಾಡಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ. CAS ಯಶಸ್ವಿಯಾಗುತ್ತದೆ ಏಕೆಂದರೆ ಮೌಲ್ಯವು ಇನ್ನೂ A ಆಗಿದೆ, ಆದರೆ ಥ್ರೆಡ್ 2 ಮಾಡಿದ ಮಧ್ಯಂತರ ಬದಲಾವಣೆಗಳು (ಥ್ರೆಡ್ 1 ಗೆ ತಿಳಿದಿಲ್ಲ) ಕಾರ್ಯಾಚರಣೆಯ ಊಹೆಗಳನ್ನು ಅಮಾನ್ಯಗೊಳಿಸಬಹುದು.

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

3. ಮೆಮೊರಿ ಮ್ಯಾನೇಜ್ಮೆಂಟ್

C++ ನಂತಹ ಭಾಷೆಗಳಲ್ಲಿ, ಲಾಕ್-ಫ್ರೀ ರಚನೆಗಳಲ್ಲಿ ಹಸ್ತಚಾಲಿತ ಮೆಮೊರಿ ನಿರ್ವಹಣೆ ಮತ್ತಷ್ಟು ಸಂಕೀರ್ಣತೆಯನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ. ಲಾಕ್-ಫ್ರೀ ಲಿಂಕ್ಡ್ ಲಿಸ್ಟ್‌ನಲ್ಲಿನ ನೋಡ್ ಅನ್ನು ತಾರ್ಕಿಕವಾಗಿ ತೆಗೆದುಹಾಕಿದಾಗ, ಅದನ್ನು ತಕ್ಷಣವೇ ಡಿಅಲೋಕೇಟ್ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ ಏಕೆಂದರೆ ಇತರ ಥ್ರೆಡ್‌ಗಳು ಇನ್ನೂ ಅದರ ಮೇಲೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿರಬಹುದು, ತಾರ್ಕಿಕವಾಗಿ ತೆಗೆದುಹಾಕುವ ಮೊದಲು ಅದಕ್ಕೆ ಪಾಯಿಂಟರ್ ಅನ್ನು ಓದಿರಬಹುದು. ಇದಕ್ಕೆ ಅತ್ಯಾಧುನಿಕ ಮೆಮೊರಿ ರಿಕ್ಲಮೇಷನ್ ತಂತ್ರಗಳು ಬೇಕಾಗುತ್ತವೆ:

• ಎಪೋಕ್-ಬೇಸ್ಡ್ ರಿಕ್ಲಮೇಷನ್ (EBR): ಥ್ರೆಡ್‌ಗಳು ಎಪೋಕ್‌ಗಳೊಳಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ. ಎಲ್ಲಾ ಥ್ರೆಡ್‌ಗಳು ನಿರ್ದಿಷ್ಟ ಎಪೋಕ್ ಅನ್ನು ದಾಟಿದಾಗ ಮಾತ್ರ ಮೆಮೊರಿಯನ್ನು ಮರುಪಡೆಯಲಾಗುತ್ತದೆ.
• ಹಜಾರ್ಡ್ ಪಾಯಿಂಟರ್‌ಗಳು: ಥ್ರೆಡ್‌ಗಳು ಪ್ರಸ್ತುತ ಪ್ರವೇಶಿಸುತ್ತಿರುವ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ನೋಂದಾಯಿಸುತ್ತವೆ. ಯಾವುದೇ ಥ್ರೆಡ್ ಅದಕ್ಕೆ ಹಜಾರ್ಡ್ ಪಾಯಿಂಟರ್ ಹೊಂದಿಲ್ಲದಿದ್ದರೆ ಮಾತ್ರ ಮೆಮೊರಿಯನ್ನು ಮರುಪಡೆಯಬಹುದು.
• ರೆಫರೆನ್ಸ್ ಕೌಂಟಿಂಗ್: ಸರಳವೆಂದು ತೋರುತ್ತದೆಯಾದರೂ, ಲಾಕ್-ಫ್ರೀ ರೀತಿಯಲ್ಲಿ ಅಟಾಮಿಕ್ ರೆಫರೆನ್ಸ್ ಕೌಂಟಿಂಗ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು ಸ್ವತಃ ಸಂಕೀರ್ಣವಾಗಿದೆ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯ ಪರಿಣಾಮಗಳನ್ನು ಹೊಂದಿರಬಹುದು.

ಗಾರ್ಬೇಜ್ ಕಲೆಕ್ಷನ್ (Java ಅಥವಾ C# ನಂತಹ) ಹೊಂದಿರುವ ನಿರ್ವಹಿಸಲಾದ ಭಾಷೆಗಳು ಮೆಮೊರಿ ನಿರ್ವಹಣೆಯನ್ನು ಸರಳಗೊಳಿಸಬಹುದು, ಆದರೆ ಅವು GC ವಿರಾಮಗಳು ಮತ್ತು ಲಾಕ್-ಫ್ರೀ ಗ್ಯಾರಂಟಿಗಳ ಮೇಲೆ ಅವುಗಳ ಪ್ರಭಾವಕ್ಕೆ ಸಂಬಂಧಿಸಿದಂತೆ ತಮ್ಮದೇ ಆದ ಸಂಕೀರ್ಣತೆಗಳನ್ನು ಪರಿಚಯಿಸುತ್ತವೆ.

4. ಕಾರ್ಯಕ್ಷಮತೆಯ ಮುನ್ಸೂಚನೆ

ಲಾಕ್-ಫ್ರೀ ಉತ್ತಮ ಸರಾಸರಿ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ನೀಡಬಹುದಾದರೂ, CAS ಲೂಪ್‌ಗಳಲ್ಲಿನ ಪುನರಾವರ್ತನೆಗಳಿಂದಾಗಿ ವೈಯಕ್ತಿಕ ಕಾರ್ಯಾಚರಣೆಗಳು ಹೆಚ್ಚು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳಬಹುದು. ಇದು ಲಾಕ್-ಆಧಾರಿತ ವಿಧಾನಗಳಿಗೆ ಹೋಲಿಸಿದರೆ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಕಡಿಮೆ ಊಹಿಸುವಂತೆ ಮಾಡಬಹುದು, ಅಲ್ಲಿ ಲಾಕ್‌ಗಾಗಿ ಗರಿಷ್ಠ ಕಾಯುವ ಸಮಯವು ಆಗಾಗ್ಗೆ ಸೀಮಿತವಾಗಿರುತ್ತದೆ (ಆದರೂ ಡೆಡ್‌ಲಾಕ್‌ಗಳ ಸಂದರ್ಭದಲ್ಲಿ ಸಂಭಾವ್ಯವಾಗಿ ಅನಂತವಾಗಿರುತ್ತದೆ).

5. ಡೀಬಗ್ಗಿಂಗ್ ಮತ್ತು ಟೂಲಿಂಗ್

ಲಾಕ್-ಫ್ರೀ ಕೋಡ್ ಅನ್ನು ಡೀಬಗ್ ಮಾಡುವುದು ಗಮನಾರ್ಹವಾಗಿ ಕಷ್ಟ. ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಡೀಬಗ್ಗಿಂಗ್ ಉಪಕರಣಗಳು ಅಟಾಮಿಕ್ ಕಾರ್ಯಾಚರಣೆಗಳ ಸಮಯದಲ್ಲಿ ಸಿಸ್ಟಮ್‌ನ ಸ್ಥಿತಿಯನ್ನು ನಿಖರವಾಗಿ ಪ್ರತಿಬಿಂಬಿಸದಿರಬಹುದು, ಮತ್ತು ಎಕ್ಸಿಕ್ಯೂಶನ್ ಫ್ಲೋವನ್ನು ದೃಶ್ಯೀಕರಿಸುವುದು ಸವಾಲಾಗಿರಬಹುದು.

ಲಾಕ್-ಫ್ರೀ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಎಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ?

ಕೆಲವು ಡೊಮೇನ್‌ಗಳ ಬೇಡಿಕೆಯ ಕಾರ್ಯಕ್ಷಮತೆ ಮತ್ತು ಸ್ಕೇಲೆಬಿಲಿಟಿ ಅವಶ್ಯಕತೆಗಳು ಲಾಕ್-ಫ್ರೀ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಅನಿವಾರ್ಯ ಸಾಧನವನ್ನಾಗಿ ಮಾಡುತ್ತದೆ. ಜಾಗತಿಕ ಉದಾಹರಣೆಗಳು ಹೇರಳವಾಗಿವೆ:

• ಹೈ-ಫ್ರೀಕ್ವೆನ್ಸಿ ಟ್ರೇಡಿಂಗ್ (HFT): ಮಿಲಿಸೆಕೆಂಡ್‌ಗಳು ಮುಖ್ಯವಾಗಿರುವ ಹಣಕಾಸು ಮಾರುಕಟ್ಟೆಗಳಲ್ಲಿ, ಲಾಕ್-ಫ್ರೀ ಡೇಟಾ ರಚನೆಗಳನ್ನು ಆರ್ಡರ್ ಬುಕ್‌ಗಳು, ಟ್ರೇಡ್ ಎಕ್ಸಿಕ್ಯೂಶನ್, ಮತ್ತು ರಿಸ್ಕ್ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ಕನಿಷ್ಠ ಲೇಟೆನ್ಸಿಯೊಂದಿಗೆ ನಿರ್ವಹಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಲಂಡನ್, ನ್ಯೂಯಾರ್ಕ್, ಮತ್ತು ಟೋಕಿಯೋ ಎಕ್ಸ್‌ಚೇಂಜ್‌ಗಳಲ್ಲಿನ ಸಿಸ್ಟಮ್‌ಗಳು ಅಪಾರ ಸಂಖ್ಯೆಯ ವಹಿವಾಟುಗಳನ್ನು ತೀವ್ರ ವೇಗದಲ್ಲಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಇಂತಹ ತಂತ್ರಗಳನ್ನು ಅವಲಂಬಿಸಿವೆ.
• ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಕರ್ನಲ್‌ಗಳು: ಆಧುನಿಕ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್‌ಗಳು (ಲಿನಕ್ಸ್, ವಿಂಡೋಸ್, ಮ್ಯಾಕ್ಓಎಸ್ ನಂತಹ) ಶೆಡ್ಯೂಲಿಂಗ್ ಕ್ಯೂಗಳು, ಇಂಟರಪ್ಟ್ ಹ್ಯಾಂಡ್ಲಿಂಗ್, ಮತ್ತು ಇಂಟರ್-ಪ್ರೊಸೆಸ್ ಕಮ್ಯುನಿಕೇಷನ್‌ನಂತಹ ನಿರ್ಣಾಯಕ ಕರ್ನಲ್ ಡೇಟಾ ರಚನೆಗಳಿಗೆ ಲಾಕ್-ಫ್ರೀ ತಂತ್ರಗಳನ್ನು ಬಳಸುತ್ತವೆ, ಭಾರೀ ಹೊರೆಯ ಅಡಿಯಲ್ಲಿ ಸ್ಪಂದನಾಶೀಲತೆಯನ್ನು ಕಾಪಾಡಿಕೊಳ್ಳಲು.
• ಡೇಟಾಬೇಸ್ ಸಿಸ್ಟಮ್‌ಗಳು: ಉನ್ನತ-ಕಾರ್ಯಕ್ಷಮತೆಯ ಡೇಟಾಬೇಸ್‌ಗಳು ಆಗಾಗ್ಗೆ ಆಂತರಿಕ ಕ್ಯಾಶ್‌ಗಳು, ವಹಿವಾಟು ನಿರ್ವಹಣೆ, ಮತ್ತು ಇಂಡೆಕ್ಸಿಂಗ್‌ಗಾಗಿ ಲಾಕ್-ಫ್ರೀ ರಚನೆಗಳನ್ನು ಬಳಸುತ್ತವೆ, ಜಾಗತಿಕ ಬಳಕೆದಾರರ ನೆಲೆಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತಾ, ವೇಗದ ಓದುವ ಮತ್ತು ಬರೆಯುವ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು.
• ಗೇಮ್ ಇಂಜಿನ್‌ಗಳು: ಸಂಕೀರ್ಣ ಗೇಮ್ ವರ್ಲ್ಡ್‌ಗಳಲ್ಲಿ (ಆಗಾಗ್ಗೆ ವಿಶ್ವಾದ್ಯಂತ ಯಂತ್ರಗಳಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ) ಬಹು ಥ್ರೆಡ್‌ಗಳಾದ್ಯಂತ ಗೇಮ್ ಸ್ಟೇಟ್, ಭೌತಶಾಸ್ತ್ರ, ಮತ್ತು AI ಯ ನೈಜ-ಸಮಯದ ಸಿಂಕ್ರೊನೈಸೇಶನ್ ಲಾಕ್-ಫ್ರೀ ವಿಧಾನಗಳಿಂದ ಪ್ರಯೋಜನ ಪಡೆಯುತ್ತದೆ.
• ನೆಟ್‌ವರ್ಕಿಂಗ್ ಉಪಕರಣಗಳು: ರೂಟರ್‌ಗಳು, ಫೈರ್‌ವಾಲ್‌ಗಳು, ಮತ್ತು ಹೈ-ಸ್ಪೀಡ್ ನೆಟ್‌ವರ್ಕ್ ಸ್ವಿಚ್‌ಗಳು ಆಗಾಗ್ಗೆ ಲಾಕ್-ಫ್ರೀ ಕ್ಯೂಗಳು ಮತ್ತು ಬಫರ್‌ಗಳನ್ನು ಬಳಸಿ ನೆಟ್‌ವರ್ಕ್ ಪ್ಯಾಕೆಟ್‌ಗಳನ್ನು ಡ್ರಾಪ್ ಮಾಡದೆ ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತವೆ, ಇದು ಜಾಗತಿಕ ಇಂಟರ್ನೆಟ್ ಮೂಲಸೌಕರ್ಯಕ್ಕೆ ನಿರ್ಣಾಯಕವಾಗಿದೆ.
• ವೈಜ್ಞಾನಿಕ ಸಿಮ್ಯುಲೇಶನ್‌ಗಳು: ಹವಾಮಾನ ಮುನ್ಸೂಚನೆ, ಆಣ್ವಿಕ ಡೈನಾಮಿಕ್ಸ್, ಮತ್ತು ಆಸ್ಟ್ರೋಫಿಸಿಕಲ್ ಮಾಡೆಲಿಂಗ್‌ನಂತಹ ಕ್ಷೇತ್ರಗಳಲ್ಲಿನ ದೊಡ್ಡ ಪ್ರಮಾಣದ ಸಮಾನಾಂತರ ಸಿಮ್ಯುಲೇಶನ್‌ಗಳು ಸಾವಿರಾರು ಪ್ರೊಸೆಸರ್ ಕೋರ್‌ಗಳಾದ್ಯಂತ ಹಂಚಿದ ಡೇಟಾವನ್ನು ನಿರ್ವಹಿಸಲು ಲಾಕ್-ಫ್ರೀ ಡೇಟಾ ರಚನೆಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳುತ್ತವೆ.

ಲಾಕ್-ಫ್ರೀ ರಚನೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು: ಒಂದು ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆ (ಪರಿಕಲ್ಪನಾತ್ಮಕ)

CAS ಬಳಸಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾದ ಸರಳ ಲಾಕ್-ಫ್ರೀ ಸ್ಟಾಕ್ ಅನ್ನು ಪರಿಗಣಿಸೋಣ. ಸ್ಟಾಕ್ ಸಾಮಾನ್ಯವಾಗಿ `push` ಮತ್ತು `pop` ನಂತಹ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ.

ಡೇಟಾ ರಚನೆ:

struct Node {
    Value data;
    Node* next;
};

class LockFreeStack {
private:
    std::atomic head;

public:
    void push(Value val) {
        Node* newNode = new Node{val, nullptr};
        Node* oldHead;
        do {
            oldHead = head.load(); // ಪ್ರಸ್ತುತ ಹೆಡ್ ಅನ್ನು ಅಟಾಮಿಕ್ ಆಗಿ ಓದಿ
            newNode->next = oldHead;
            // ಹೆಡ್ ಬದಲಾಗದಿದ್ದರೆ, ಹೊಸ ಹೆಡ್ ಅನ್ನು ಅಟಾಮಿಕ್ ಆಗಿ ಸೆಟ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿ
        } while (!head.compare_exchange_weak(oldHead, newNode));
    }

    Value pop() {
        Node* oldHead;
        Value val;
        do {
            oldHead = head.load(); // ಪ್ರಸ್ತುತ ಹೆಡ್ ಅನ್ನು ಅಟಾಮಿಕ್ ಆಗಿ ಓದಿ
            if (!oldHead) {
                // ಸ್ಟಾಕ್ ಖಾಲಿಯಾಗಿದೆ, ಸೂಕ್ತವಾಗಿ ನಿಭಾಯಿಸಿ (ಉದಾ., ವಿನಾಯಿತಿ ಎಸೆಯಿರಿ ಅಥವಾ ಸೆಂಟಿನೆಲ್ ಹಿಂತಿರುಗಿಸಿ)
                throw std::runtime_error("ಸ್ಟಾಕ್ ಅಂಡರ್‌ಫ್ಲೋ");
            }
            // ಪ್ರಸ್ತುತ ಹೆಡ್ ಅನ್ನು ಮುಂದಿನ ನೋಡ್‌ನ ಪಾಯಿಂಟರ್‌ನೊಂದಿಗೆ ಸ್ವಾಪ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿ
            // ಯಶಸ್ವಿಯಾದರೆ, oldHead ಪಾಪ್ ಆಗುತ್ತಿರುವ ನೋಡ್‌ಗೆ ಪಾಯಿಂಟ್ ಮಾಡುತ್ತದೆ
        } while (!head.compare_exchange_weak(oldHead, oldHead->next));

        val = oldHead->data;
        // ಸಮಸ್ಯೆ: oldHead ಅನ್ನು ABA ಅಥವಾ ಯೂಸ್-ಆಫ್ಟರ್-ಫ್ರೀ ಇಲ್ಲದೆ ಸುರಕ್ಷಿತವಾಗಿ ಡಿಲೀಟ್ ಮಾಡುವುದು ಹೇಗೆ?
        // ಇಲ್ಲಿಯೇ ಸುಧಾರಿತ ಮೆಮೊರಿ ರಿಕ್ಲಮೇಷನ್ ಅಗತ್ಯವಿದೆ.
        // ಪ್ರದರ್ಶನಕ್ಕಾಗಿ, ನಾವು ಸುರಕ್ಷಿತ ಡಿಲೀಷನ್ ಅನ್ನು ಬಿಟ್ಟುಬಿಡುತ್ತೇವೆ.
        // delete oldHead; // ನಿಜವಾದ ಮಲ್ಟಿಥ್ರೆಡೆಡ್ ಸನ್ನಿವೇಶದಲ್ಲಿ ಅಸುರಕ್ಷಿತ!
        return val;
    }
};

`push` ಕಾರ್ಯಾಚರಣೆಯಲ್ಲಿ:

1. ಹೊಸ `Node` ಅನ್ನು ರಚಿಸಲಾಗಿದೆ.
2. ಪ್ರಸ್ತುತ `head` ಅನ್ನು ಅಟಾಮಿಕ್ ಆಗಿ ಓದಲಾಗುತ್ತದೆ.
3. ಹೊಸ ನೋಡ್‌ನ `next` ಪಾಯಿಂಟರ್ ಅನ್ನು `oldHead` ಗೆ ಸೆಟ್ ಮಾಡಲಾಗಿದೆ.
4. CAS ಕಾರ್ಯಾಚರಣೆಯು `head` ಅನ್ನು `newNode` ಗೆ ಪಾಯಿಂಟ್ ಮಾಡಲು ನವೀಕರಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ. `load` ಮತ್ತು `compare_exchange_weak` ಕರೆಗಳ ನಡುವೆ `head` ಅನ್ನು ಮತ್ತೊಂದು ಥ್ರೆಡ್‌ನಿಂದ ಮಾರ್ಪಡಿಸಿದ್ದರೆ, CAS ವಿಫಲಗೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಲೂಪ್ ಪುನಃ ಪ್ರಯತ್ನಿಸುತ್ತದೆ.

`pop` ಕಾರ್ಯಾಚರಣೆಯಲ್ಲಿ:

1. ಪ್ರಸ್ತುತ `head` ಅನ್ನು ಅಟಾಮಿಕ್ ಆಗಿ ಓದಲಾಗುತ್ತದೆ.
2. ಸ್ಟಾಕ್ ಖಾಲಿಯಾಗಿದ್ದರೆ (`oldHead` ಶೂನ್ಯವಾಗಿದ್ದರೆ), ದೋಷವನ್ನು ಸಂಕೇತಿಸಲಾಗುತ್ತದೆ.
3. CAS ಕಾರ್ಯಾಚರಣೆಯು `head` ಅನ್ನು `oldHead->next` ಗೆ ಪಾಯಿಂಟ್ ಮಾಡಲು ನವೀಕರಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ. `head` ಅನ್ನು ಮತ್ತೊಂದು ಥ್ರೆಡ್‌ನಿಂದ ಮಾರ್ಪಡಿಸಿದ್ದರೆ, CAS ವಿಫಲಗೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಲೂಪ್ ಪುನಃ ಪ್ರಯತ್ನಿಸುತ್ತದೆ.
4. CAS ಯಶಸ್ವಿಯಾದರೆ, `oldHead` ಈಗ ಸ್ಟಾಕ್‌ನಿಂದ ತೆಗೆದುಹಾಕಲಾದ ನೋಡ್‌ಗೆ ಪಾಯಿಂಟ್ ಮಾಡುತ್ತದೆ. ಅದರ ಡೇಟಾವನ್ನು ಹಿಂಪಡೆಯಲಾಗುತ್ತದೆ.

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

ಸರಿಯಾದ ವಿಧಾನವನ್ನು ಆರಿಸುವುದು: ಲಾಕ್ಸ್ vs. ಲಾಕ್-ಫ್ರೀ

ಲಾಕ್-ಫ್ರೀ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಬಳಸುವ ನಿರ್ಧಾರವು ಅಪ್ಲಿಕೇಶನ್‌ನ ಅವಶ್ಯಕತೆಗಳ ಎಚ್ಚರಿಕೆಯ ವಿಶ್ಲೇಷಣೆಯನ್ನು ಆಧರಿಸಿರಬೇಕು:

• ಕಡಿಮೆ ಸ್ಪರ್ಧೆ: ಅತಿ ಕಡಿಮೆ ಥ್ರೆಡ್ ಸ್ಪರ್ಧೆಯಿರುವ ಸನ್ನಿವೇಶಗಳಿಗೆ, ಸಾಂಪ್ರದಾಯಿಕ ಲಾಕ್‌ಗಳು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಮತ್ತು ಡೀಬಗ್ ಮಾಡಲು ಸರಳವಾಗಿರಬಹುದು, ಮತ್ತು ಅವುಗಳ ಓವರ್‌ಹೆಡ್ ನಗಣ್ಯವಾಗಿರಬಹುದು.
• ಹೆಚ್ಚಿನ ಸ್ಪರ್ಧೆ ಮತ್ತು ಲೇಟೆನ್ಸಿ ಸಂವೇದನೆ: ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಹೆಚ್ಚಿನ ಸ್ಪರ್ಧೆಯನ್ನು ಅನುಭವಿಸಿದರೆ ಮತ್ತು ಊಹಿಸಬಹುದಾದ ಕಡಿಮೆ ಲೇಟೆನ್ಸಿ ಅಗತ್ಯವಿದ್ದರೆ, ಲಾಕ್-ಫ್ರೀ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಗಮನಾರ್ಹ ಪ್ರಯೋಜನಗಳನ್ನು ಒದಗಿಸಬಹುದು.
• ಸಿಸ್ಟಮ್-ವೈಡ್ ಪ್ರಗತಿ ಗ್ಯಾರಂಟಿ: ಲಾಕ್ ಸ್ಪರ್ಧೆಯಿಂದಾಗಿ ಸಿಸ್ಟಮ್ ಸ್ಥಗಿತಗೊಳ್ಳುವುದನ್ನು ತಪ್ಪಿಸುವುದು (ಡೆಡ್‌ಲಾಕ್‌ಗಳು, ಆದ್ಯತೆಯ ವಿಲೋಮ) ನಿರ್ಣಾಯಕವಾಗಿದ್ದರೆ, ಲಾಕ್-ಫ್ರೀ ಒಂದು ಪ್ರಬಲ ಅಭ್ಯರ್ಥಿಯಾಗಿದೆ.
• ಅಭಿವೃದ್ಧಿ ಪ್ರಯತ್ನ: ಲಾಕ್-ಫ್ರೀ ಅಲ್ಗಾರಿದಮ್‌ಗಳು ಗಣನೀಯವಾಗಿ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾಗಿವೆ. ಲಭ್ಯವಿರುವ ಪರಿಣತಿ ಮತ್ತು ಅಭಿವೃದ್ಧಿ ಸಮಯವನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಿ.

ಲಾಕ್-ಫ್ರೀ ಅಭಿವೃದ್ಧಿಗಾಗಿ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ಲಾಕ್-ಫ್ರೀ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ಗೆ ಮುಂದಾಗುವ ಡೆವಲಪರ್‌ಗಳಿಗಾಗಿ, ಈ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಪರಿಗಣಿಸಿ:

• ಬಲವಾದ ಪ್ರಿಮಿಟಿವ್‌ಗಳೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿ: ನಿಮ್ಮ ಭಾಷೆ ಅಥವಾ ಹಾರ್ಡ್‌ವೇರ್ ಒದಗಿಸಿದ ಅಟಾಮಿಕ್ ಆಪರೇಷನ್‌ಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳಿ (ಉದಾ., C++ ನಲ್ಲಿ `std::atomic`, Java ನಲ್ಲಿ `java.util.concurrent.atomic`).
• ನಿಮ್ಮ ಮೆಮೊರಿ ಮಾದರಿಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ: ವಿಭಿನ್ನ ಪ್ರೊಸೆಸರ್ ಆರ್ಕಿಟೆಕ್ಚರ್‌ಗಳು ಮತ್ತು ಕಂಪೈಲರ್‌ಗಳು ವಿಭಿನ್ನ ಮೆಮೊರಿ ಮಾದರಿಗಳನ್ನು ಹೊಂದಿವೆ. ಮೆಮೊರಿ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಹೇಗೆ ಆದೇಶಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಇತರ ಥ್ರೆಡ್‌ಗಳಿಗೆ ಗೋಚರಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ನಿಖರತೆಗೆ ನಿರ್ಣಾಯಕವಾಗಿದೆ.
• ಎಬಿಎ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಿ: CAS ಬಳಸುತ್ತಿದ್ದರೆ, ಎಬಿಎ ಸಮಸ್ಯೆಯನ್ನು ಹೇಗೆ ತಗ್ಗಿಸುವುದು ಎಂದು ಯಾವಾಗಲೂ ಪರಿಗಣಿಸಿ, ಸಾಮಾನ್ಯವಾಗಿ ಆವೃತ್ತಿ ಕೌಂಟರ್‌ಗಳು ಅಥವಾ ಟ್ಯಾಗ್ ಮಾಡಿದ ಪಾಯಿಂಟರ್‌ಗಳೊಂದಿಗೆ.
• ದೃಢವಾದ ಮೆಮೊರಿ ರಿಕ್ಲಮೇಷನ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ: ಮೆಮೊರಿಯನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ನಿರ್ವಹಿಸುತ್ತಿದ್ದರೆ, ಸುರಕ್ಷಿತ ಮೆಮೊರಿ ರಿಕ್ಲಮೇಷನ್ ತಂತ್ರಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ಸರಿಯಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಸಮಯವನ್ನು ಹೂಡಿಕೆ ಮಾಡಿ.
• ಸಂಪೂರ್ಣವಾಗಿ ಪರೀಕ್ಷಿಸಿ: ಲಾಕ್-ಫ್ರೀ ಕೋಡ್ ಅನ್ನು ಸರಿಯಾಗಿ ಮಾಡುವುದು ಕುಖ್ಯಾತವಾಗಿ ಕಷ್ಟ. ವ್ಯಾಪಕವಾದ ಯುನಿಟ್ ಪರೀಕ್ಷೆಗಳು, ಏಕೀಕರಣ ಪರೀಕ್ಷೆಗಳು ಮತ್ತು ಒತ್ತಡ ಪರೀಕ್ಷೆಗಳನ್ನು ಬಳಸಿ. ಕನ್ಕರೆನ್ಸಿ ಸಮಸ್ಯೆಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಬಲ್ಲ ಉಪಕರಣಗಳನ್ನು ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ.
• ಸರಳವಾಗಿಡಿ (ಸಾಧ್ಯವಾದಾಗ): ಅನೇಕ ಸಾಮಾನ್ಯ ಏಕಕಾಲೀನ ಡೇಟಾ ರಚನೆಗಳಿಗೆ (ಕ್ಯೂಗಳು ಅಥವಾ ಸ್ಟಾಕ್‌ಗಳಂತಹ), ಚೆನ್ನಾಗಿ ಪರೀಕ್ಷಿಸಲ್ಪಟ್ಟ ಲೈಬ್ರರಿ ಅನುಷ್ಠಾನಗಳು ಆಗಾಗ್ಗೆ ಲಭ್ಯವಿವೆ. ಅವು ನಿಮ್ಮ ಅಗತ್ಯಗಳನ್ನು ಪೂರೈಸಿದರೆ, ಚಕ್ರವನ್ನು ಮರುಶೋಧಿಸುವುದಕ್ಕಿಂತ ಅವುಗಳನ್ನು ಬಳಸಿ.
• ಪ್ರೊಫೈಲ್ ಮತ್ತು ಅಳತೆ: ಲಾಕ್-ಫ್ರೀ ಯಾವಾಗಲೂ ವೇಗವಾಗಿರುತ್ತದೆ ಎಂದು ಭಾವಿಸಬೇಡಿ. ನಿಜವಾದ ಅಡಚಣೆಗಳನ್ನು ಗುರುತಿಸಲು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪ್ರೊಫೈಲ್ ಮಾಡಿ ಮತ್ತು ಲಾಕ್-ಫ್ರೀ ಮತ್ತು ಲಾಕ್-ಆಧಾರಿತ ವಿಧಾನಗಳ ಕಾರ್ಯಕ್ಷಮತೆಯ ಪ್ರಭಾವವನ್ನು ಅಳೆಯಿರಿ.
• ಪರಿಣತಿಯನ್ನು ಹುಡುಕಿ: ಸಾಧ್ಯವಾದರೆ, ಲಾಕ್-ಫ್ರೀ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿ ಅನುಭವಿ ಡೆವಲಪರ್‌ಗಳೊಂದಿಗೆ ಸಹಕರಿಸಿ ಅಥವಾ ವಿಶೇಷ ಸಂಪನ್ಮೂಲಗಳು ಮತ್ತು ಶೈಕ್ಷಣಿಕ ಪತ್ರಿಕೆಗಳನ್ನು ಸಂಪರ್ಕಿಸಿ.

ತೀರ್ಮಾನ

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