ಕೋರ್ಸ್ ವಿದ್ಯಾರ್ಥಿಗಳಿಗೆ ಸಿದ್ಧಪಡಿಸಿದ ಲೇಖನದ ಅನುವಾದ "ಲಿನಕ್ಸ್ ನಿರ್ವಾಹಕರು".

ಹಿಂದೆ, ನಾನು Linux ನಲ್ಲಿ Hugepages ಅನ್ನು ಹೇಗೆ ಪರೀಕ್ಷಿಸುವುದು ಮತ್ತು ಸಕ್ರಿಯಗೊಳಿಸುವುದು ಎಂಬುದರ ಕುರಿತು ಮಾತನಾಡಿದ್ದೇನೆ.
ನೀವು ನಿಜವಾಗಿಯೂ Hugepages ಅನ್ನು ಬಳಸಲು ಸ್ಥಳವನ್ನು ಹೊಂದಿದ್ದರೆ ಮಾತ್ರ ಈ ಲೇಖನವು ಉಪಯುಕ್ತವಾಗಿರುತ್ತದೆ. Hugepages ಮಾಂತ್ರಿಕವಾಗಿ ಉತ್ಪಾದಕತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ ಎಂಬ ನಿರೀಕ್ಷೆಯಿಂದ ಮೂರ್ಖರಾಗಿರುವ ಬಹಳಷ್ಟು ಜನರನ್ನು ನಾನು ಭೇಟಿ ಮಾಡಿದ್ದೇನೆ. ಆದಾಗ್ಯೂ, ಬೃಹತ್ ಪೇಜಿಂಗ್ ಒಂದು ಸಂಕೀರ್ಣ ವಿಷಯವಾಗಿದೆ ಮತ್ತು ತಪ್ಪಾಗಿ ಬಳಸಿದರೆ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಕುಗ್ಗಿಸಬಹುದು.

ಭಾಗ 1: ಲಿನಕ್ಸ್‌ನಲ್ಲಿ ಬೃಹತ್ ಪುಟಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುವುದು (ಮೂಲ ಇಲ್ಲಿ)

ಸಮಸ್ಯೆ:
ನಿಮ್ಮ ಸಿಸ್ಟಂನಲ್ಲಿ HugePages ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲಾಗಿದೆಯೇ ಎಂದು ನೀವು ಪರಿಶೀಲಿಸಬೇಕು.

ಪರಿಹಾರ:
ಇದು ಬಹಳ ಸರಳವಾಗಿದೆ:

cat /sys/kernel/mm/transparent_hugepage/enabled

ನೀವು ಈ ರೀತಿಯದನ್ನು ಪಡೆಯುತ್ತೀರಿ:

always [madvise] never

ಲಭ್ಯವಿರುವ ಆಯ್ಕೆಗಳ ಪಟ್ಟಿಯನ್ನು ನೀವು ನೋಡುತ್ತೀರಿ (ಯಾವಾಗಲೂ, ಹುಚ್ಚು, ಎಂದಿಗೂ), ಮತ್ತು ಪ್ರಸ್ತುತ ಸಕ್ರಿಯ ಆಯ್ಕೆಯನ್ನು ಆವರಣಗಳಲ್ಲಿ ಸುತ್ತುವರಿಯಲಾಗುತ್ತದೆ (ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಹುಚ್ಚುಮಾಡು).

ಹುಚ್ಚುಮಾಡು ಎಂದು ಅರ್ಥ transparent hugepages ಬಳಸಿ ಬೃಹತ್ ಪುಟಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ವಿನಂತಿಸುವ ಮೆಮೊರಿ ಪ್ರದೇಶಗಳಿಗೆ ಮಾತ್ರ ಸಕ್ರಿಯಗೊಳಿಸಲಾಗಿದೆ ಹುಚ್ಚು (2).

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

ಎಂದಿಗೂ ಎಂದು ಅರ್ಥ transparent hugepages madvise ಬಳಸಿ ವಿನಂತಿಸಿದಾಗಲೂ ಸೇರಿಸಲಾಗುವುದಿಲ್ಲ. ಹೆಚ್ಚಿನದನ್ನು ಕಂಡುಹಿಡಿಯಲು, ಸಂಪರ್ಕಿಸಿ ದಸ್ತಾವೇಜನ್ನು ಲಿನಕ್ಸ್ ಕರ್ನಲ್‌ಗಳು.

ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯವನ್ನು ಹೇಗೆ ಬದಲಾಯಿಸುವುದು

ಆಯ್ಕೆ 1: ನೇರವಾಗಿ ಬದಲಾಯಿಸಿ sysfs (ರೀಬೂಟ್ ಮಾಡಿದ ನಂತರ ನಿಯತಾಂಕವು ಅದರ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯಕ್ಕೆ ಮರಳುತ್ತದೆ):

echo always >/sys/kernel/mm/transparent_hugepage/enabled
echo madvise >/sys/kernel/mm/transparent_hugepage/enabled
echo never >/sys/kernel/mm/transparent_hugepage/enabled

ಆಯ್ಕೆ 2: ಮಾರ್ಪಡಿಸಿದ ಸಂರಚನೆಯೊಂದಿಗೆ ಕರ್ನಲ್ ಅನ್ನು ಮರುಕಂಪೈಲ್ ಮಾಡುವ ಮೂಲಕ ಸಿಸ್ಟಮ್ ಡೀಫಾಲ್ಟ್ ಅನ್ನು ಬದಲಾಯಿಸಿ (ನೀವು ಕಸ್ಟಮ್ ಕರ್ನಲ್ ಅನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ ಮಾತ್ರ ಈ ಆಯ್ಕೆಯನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ):

ಯಾವಾಗಲೂ ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಹೊಂದಿಸಲು, ಬಳಸಿ:
```
CONFIG_TRANSPARENT_HUGEPAGE_ALWAYS=y
# Comment out CONFIG_TRANSPARENT_HUGEPAGE_MADVISE=y
```
ಮ್ಯಾಡ್ವೈಸ್ ಅನ್ನು ಡೀಫಾಲ್ಟ್ ಆಗಿ ಹೊಂದಿಸಲು, ಬಳಸಿ:
```
CONFIG_TRANSPARENT_HUGEPAGE_MADVISE=y
# Comment out CONFIG_TRANSPARENT_HUGEPAGE_ALWAYS=y
```

ಭಾಗ 2: ಬೃಹತ್ ಪುಟಗಳ ಅನುಕೂಲಗಳು ಮತ್ತು ಅನಾನುಕೂಲಗಳು

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

ನಾವು ಲಿನಕ್ಸ್ ಚಾಲನೆಯಲ್ಲಿರುವ 64-ಬಿಟ್ x86 ಸಿಸ್ಟಮ್‌ಗಳ ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತಿದ್ದೇವೆ ಮತ್ತು ಯಾವುದೇ ಆಧುನಿಕ ಲಿನಕ್ಸ್‌ನಲ್ಲಿರುವಂತೆ, ಪಾರದರ್ಶಕ ಬೃಹತ್ ಪುಟಗಳನ್ನು (ಹ್ಯಾಜ್‌ಪೇಜ್‌ಗಳನ್ನು ತಿದ್ದಿ ಬರೆಯದಿರುವುದು ಅನನುಕೂಲವಲ್ಲವಾದ್ದರಿಂದ) ಸಿಸ್ಟಮ್ ಬೆಂಬಲಿಸುತ್ತದೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಪರಿಸರ.

ಕೆಳಗಿನ ಲಿಂಕ್‌ಗಳಲ್ಲಿ ನಾನು ಹೆಚ್ಚಿನ ತಾಂತ್ರಿಕ ವಿವರಣೆಯನ್ನು ಲಗತ್ತಿಸುತ್ತೇನೆ.

ವರ್ಚುವಲ್ ಮೆಮೊರಿ

ನೀವು C++ ಪ್ರೋಗ್ರಾಮರ್ ಆಗಿದ್ದರೆ, ಮೆಮೊರಿಯಲ್ಲಿರುವ ವಸ್ತುಗಳು ನಿರ್ದಿಷ್ಟ ವಿಳಾಸಗಳನ್ನು (ಪಾಯಿಂಟರ್ ಮೌಲ್ಯಗಳು) ಹೊಂದಿವೆ ಎಂದು ನಿಮಗೆ ತಿಳಿದಿದೆ.

ಆದಾಗ್ಯೂ, ಈ ವಿಳಾಸಗಳು ಮೆಮೊರಿಯಲ್ಲಿ ಭೌತಿಕ ವಿಳಾಸಗಳನ್ನು ಪ್ರತಿಬಿಂಬಿಸುವುದಿಲ್ಲ (RAM ವಿಳಾಸಗಳು). ಅವರು ವರ್ಚುವಲ್ ಮೆಮೊರಿಯಲ್ಲಿ ವಿಳಾಸಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತಾರೆ. ಪ್ರೊಸೆಸರ್ ವಿಶೇಷ MMU (ಮೆಮೊರಿ ಮ್ಯಾನೇಜ್ಮೆಂಟ್ ಯೂನಿಟ್) ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಹೊಂದಿದ್ದು ಅದು ಕರ್ನಲ್ ಮ್ಯಾಪ್ ವರ್ಚುವಲ್ ಮೆಮೊರಿಯನ್ನು ಭೌತಿಕ ಸ್ಥಳಕ್ಕೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ಈ ವಿಧಾನವು ಅನೇಕ ಪ್ರಯೋಜನಗಳನ್ನು ಹೊಂದಿದೆ, ಆದರೆ ಮುಖ್ಯವಾದವುಗಳು:

ಕಾರ್ಯಕ್ಷಮತೆ (ವಿವಿಧ ಕಾರಣಗಳಿಗಾಗಿ);
ಪ್ರೋಗ್ರಾಂ ಪ್ರತ್ಯೇಕತೆ, ಅಂದರೆ, ಯಾವುದೇ ಪ್ರೋಗ್ರಾಂ ಮತ್ತೊಂದು ಪ್ರೋಗ್ರಾಂನ ಮೆಮೊರಿಯಿಂದ ಓದಲು ಸಾಧ್ಯವಿಲ್ಲ.

ಪುಟಗಳು ಯಾವುವು?

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

ನೀವು ವ್ಯವಹರಿಸುವ ಹೆಚ್ಚಿನ ಪುಟಗಳು RAM ಗೆ ಪಾಯಿಂಟ್ ಅಥವಾ ಬದಲಾಯಿಸಲ್ಪಡುತ್ತವೆ, ಅಂದರೆ ಅವುಗಳನ್ನು ನಿಮ್ಮ ಹಾರ್ಡ್ ಡ್ರೈವ್ ಅಥವಾ SSD ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ. ಕರ್ನಲ್ ಪ್ರತಿ ಪುಟದ ಭೌತಿಕ ವಿನ್ಯಾಸವನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ. ವಂಚನೆಯ ಪುಟವನ್ನು ಪ್ರವೇಶಿಸಿದರೆ, ಮೆಮೊರಿಯನ್ನು ಪ್ರವೇಶಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಥ್ರೆಡ್ ಅನ್ನು ಕರ್ನಲ್ ನಿಲ್ಲಿಸುತ್ತದೆ, ಹಾರ್ಡ್ ಡ್ರೈವ್/ಎಸ್‌ಎಸ್‌ಡಿಯಿಂದ RAM ಗೆ ಪುಟವನ್ನು ಓದುತ್ತದೆ ಮತ್ತು ನಂತರ ಥ್ರೆಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದನ್ನು ಮುಂದುವರಿಸುತ್ತದೆ.

ಈ ಪ್ರಕ್ರಿಯೆಯು ಸ್ಟ್ರೀಮ್ ಪಾರದರ್ಶಕವಾಗಿರುತ್ತದೆ, ಅಂದರೆ ಇದು HDD/SSD ಯಿಂದ ನೇರವಾಗಿ ಓದಬೇಕಾಗಿಲ್ಲ. ಸಾಮಾನ್ಯ ಪುಟಗಳ ಗಾತ್ರ 4096 ಬೈಟ್‌ಗಳು. ದೊಡ್ಡ ಪುಟಗಳ ಗಾತ್ರ 2 ಮೆಗಾಬೈಟ್‌ಗಳು.

ಅನುವಾದ-ಅಸೋಸಿಯೇಟಿವ್ ಬಫರ್ (TLB)

ಪ್ರೋಗ್ರಾಂ ಮೆಮೊರಿಯ ಪುಟವನ್ನು ಪ್ರವೇಶಿಸಿದಾಗ, ಯಾವ ಭೌತಿಕ ಪುಟದಿಂದ ಡೇಟಾವನ್ನು ಓದಬೇಕೆಂದು CPU ತಿಳಿದಿರಬೇಕು (ಅಂದರೆ, ವರ್ಚುವಲ್ ವಿಳಾಸ ನಕ್ಷೆಯನ್ನು ಹೊಂದಿರಿ).

ಕರ್ನಲ್ ಡೇಟಾ ರಚನೆಯನ್ನು ಹೊಂದಿದೆ (ಪುಟ ಕೋಷ್ಟಕ) ಅದು ಬಳಸುತ್ತಿರುವ ಪುಟಗಳ ಬಗ್ಗೆ ಎಲ್ಲಾ ಮಾಹಿತಿಯನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಈ ಡೇಟಾ ರಚನೆಯನ್ನು ಬಳಸಿಕೊಂಡು, ನೀವು ಭೌತಿಕ ವಿಳಾಸಕ್ಕೆ ವರ್ಚುವಲ್ ವಿಳಾಸವನ್ನು ಮ್ಯಾಪ್ ಮಾಡಬಹುದು.

ಆದಾಗ್ಯೂ, ಪುಟದ ಕೋಷ್ಟಕವು ಸಾಕಷ್ಟು ಸಂಕೀರ್ಣವಾಗಿದೆ ಮತ್ತು ನಿಧಾನವಾಗಿದೆ, ಆದ್ದರಿಂದ ಪ್ರಕ್ರಿಯೆಯು ಮೆಮೊರಿಯನ್ನು ಪ್ರವೇಶಿಸಿದಾಗಲೆಲ್ಲಾ ನಾವು ಸಂಪೂರ್ಣ ಡೇಟಾ ರಚನೆಯನ್ನು ವಿಶ್ಲೇಷಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.

ಅದೃಷ್ಟವಶಾತ್, ನಮ್ಮ ಪ್ರೊಸೆಸರ್ TLB ಅನ್ನು ಹೊಂದಿದ್ದು ಅದು ವರ್ಚುವಲ್ ಮತ್ತು ಭೌತಿಕ ವಿಳಾಸಗಳ ನಡುವೆ ಮ್ಯಾಪಿಂಗ್ ಅನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ. ಇದರರ್ಥ ನಾವು ಮೊದಲ ಪ್ರವೇಶ ಪ್ರಯತ್ನದಲ್ಲಿ ಪುಟ ಕೋಷ್ಟಕವನ್ನು ಪಾರ್ಸ್ ಮಾಡಬೇಕಾಗಿದ್ದರೂ, ಪುಟಕ್ಕೆ ಎಲ್ಲಾ ನಂತರದ ಪ್ರವೇಶಗಳನ್ನು TLB ನಲ್ಲಿ ನಿರ್ವಹಿಸಬಹುದು, ಇದು ವೇಗದ ಕಾರ್ಯಾಚರಣೆಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ಇದು ಭೌತಿಕ ಸಾಧನವಾಗಿ ಅಳವಡಿಸಲ್ಪಟ್ಟಿರುವುದರಿಂದ (ಇದು ಮೊದಲ ಸ್ಥಾನದಲ್ಲಿ ವೇಗವನ್ನು ನೀಡುತ್ತದೆ), ಅದರ ಸಾಮರ್ಥ್ಯವು ಸೀಮಿತವಾಗಿದೆ. ಆದ್ದರಿಂದ ನೀವು ಹೆಚ್ಚಿನ ಪುಟಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ಬಯಸಿದರೆ, TLB ಎಲ್ಲಾ ಮ್ಯಾಪಿಂಗ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ, ಇದರಿಂದಾಗಿ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಹೆಚ್ಚು ನಿಧಾನವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

ದೊಡ್ಡ ಪುಟಗಳು ರಕ್ಷಣೆಗೆ ಬರುತ್ತವೆ

ಆದ್ದರಿಂದ TLB ಓವರ್‌ಫ್ಲೋ ಅನ್ನು ತಪ್ಪಿಸಲು ನಾವು ಏನು ಮಾಡಬಹುದು? (ಪ್ರೋಗ್ರಾಂಗೆ ಇನ್ನೂ ಅದೇ ಪ್ರಮಾಣದ ಮೆಮೊರಿ ಅಗತ್ಯವಿದೆ ಎಂದು ನಾವು ಊಹಿಸುತ್ತೇವೆ).

Hugepages ಬರುವುದು ಇಲ್ಲಿಯೇ. ಕೇವಲ ಒಂದು TLB ನಮೂದು ಅಗತ್ಯವಿರುವ 4096 ಬೈಟ್‌ಗಳ ಬದಲಿಗೆ, ಒಂದು TLB ನಮೂದು ಈಗ ದೊಡ್ಡ 2 ಮೆಗಾಬೈಟ್‌ಗಳನ್ನು ಸೂಚಿಸಬಹುದು. TLB 512 ನಮೂದುಗಳನ್ನು ಹೊಂದಿದೆ ಎಂದು ಭಾವಿಸೋಣ, ಇಲ್ಲಿ ನಾವು ದೊಡ್ಡ ಪುಟಗಳಿಲ್ಲದೆ ಹೊಂದಾಣಿಕೆ ಮಾಡಬಹುದು:

4096 b⋅512=2 MB

ನಂತರ ನಾವು ಅವರೊಂದಿಗೆ ಹೇಗೆ ಹೋಲಿಸಬಹುದು:

2 MB⋅512=1 GB

ಇದಕ್ಕಾಗಿಯೇ Hugepages ಅದ್ಭುತವಾಗಿದೆ. ಅವರು ಹೆಚ್ಚು ಶ್ರಮವಿಲ್ಲದೆ ಉತ್ಪಾದಕತೆಯನ್ನು ಸುಧಾರಿಸಬಹುದು. ಆದರೆ ಇಲ್ಲಿ ಗಮನಾರ್ಹ ಎಚ್ಚರಿಕೆಗಳಿವೆ.

ದೊಡ್ಡ ಪುಟಗಳ ವಂಚನೆ

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

ನಾವು ಈ ರೀತಿಯ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ ಎಂದು ಹೇಳೋಣ:

char* mymemory = malloc(2*1024*1024); // Возьмем это за одну Hugepage!
// Заполним mymemory какими-либо данными
// Сделаем много других вещей,
// которые приведут к подмене страницы mymemory
// ...
// Запросим доступ только к первому байту
putchar(mymemory[0]);

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನೀವು ಒಂದು ಬೈಟ್ ಅನ್ನು ಓದಲು ಹಾರ್ಡ್ ಡ್ರೈವ್/ಎಸ್‌ಎಸ್‌ಡಿಯಿಂದ 2 ಮೆಗಾಬೈಟ್‌ಗಳಷ್ಟು ಮಾಹಿತಿಯನ್ನು ಕರ್ನಲ್ ಬದಲಾಯಿಸಬೇಕಾಗುತ್ತದೆ (ಓದಲು). ಸಾಮಾನ್ಯ ಪುಟಗಳಿಗೆ ಸಂಬಂಧಿಸಿದಂತೆ, ಹಾರ್ಡ್ ಡ್ರೈವ್/ಎಸ್‌ಎಸ್‌ಡಿಯಿಂದ ಕೇವಲ 4096 ಬೈಟ್‌ಗಳನ್ನು ಓದಬೇಕಾಗುತ್ತದೆ.

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

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

ಮೆಮೊರಿಯಲ್ಲಿ ಹಂಚಿಕೆ

ನೀವು C ಅನ್ನು ಬರೆದರೆ, ಹೀಪ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ನಿರಂಕುಶವಾಗಿ ಸಣ್ಣ (ಅಥವಾ ಬಹುತೇಕ ನಿರಂಕುಶವಾಗಿ ದೊಡ್ಡ) ಪ್ರಮಾಣದ ಮೆಮೊರಿಯನ್ನು ವಿನಂತಿಸಬಹುದು ಎಂದು ನಿಮಗೆ ತಿಳಿದಿದೆ malloc(). ನಿಮಗೆ 30 ಬೈಟ್‌ಗಳ ಮೆಮೊರಿ ಬೇಕು ಎಂದು ಹೇಳೋಣ:

char* mymemory = malloc(30);

ಪ್ರೋಗ್ರಾಮರ್‌ಗೆ, ನೀವು ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್‌ನಿಂದ 30 ಬೈಟ್‌ಗಳ ಮೆಮೊರಿಯನ್ನು "ವಿನಂತಿ" ಮಾಡುತ್ತಿದ್ದೀರಿ ಮತ್ತು ಕೆಲವು ವರ್ಚುವಲ್ ಮೆಮೊರಿಗೆ ಪಾಯಿಂಟರ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತಿರುವಿರಿ ಎಂದು ಕಾಣಿಸಬಹುದು. ಆದರೆ ವಾಸ್ತವವಾಗಿ malloc () ಕಾರ್ಯದ ಒಳಗಿನಿಂದ ಕರೆ ಮಾಡುವ ಒಂದು ಸಿ ಕಾರ್ಯವಾಗಿದೆ brk ಮತ್ತು sbrk ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂನಿಂದ ಮೆಮೊರಿಯನ್ನು ವಿನಂತಿಸಲು ಅಥವಾ ಮುಕ್ತಗೊಳಿಸಲು.

ಆದಾಗ್ಯೂ, ಪ್ರತಿ ಹಂಚಿಕೆಗೆ ಹೆಚ್ಚು ಹೆಚ್ಚು ಮೆಮೊರಿಯನ್ನು ವಿನಂತಿಸುವುದು ಅಸಮರ್ಥವಾಗಿದೆ; ಕೆಲವು ಮೆಮೊರಿ ವಿಭಾಗವನ್ನು ಈಗಾಗಲೇ ಮುಕ್ತಗೊಳಿಸಲಾಗಿದೆ (free()), ಮತ್ತು ನಾವು ಅದನ್ನು ಮರುಬಳಕೆ ಮಾಡಬಹುದು. malloc() ಮುಕ್ತ ಸ್ಮರಣೆಯನ್ನು ಮರುಬಳಕೆ ಮಾಡಲು ಸಾಕಷ್ಟು ಸಂಕೀರ್ಣ ಕ್ರಮಾವಳಿಗಳನ್ನು ಅಳವಡಿಸುತ್ತದೆ.

ಅದೇ ಸಮಯದಲ್ಲಿ, ಎಲ್ಲವೂ ನಿಮಗೆ ಗಮನಿಸದೆ ಸಂಭವಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ಅದು ನಿಮ್ಮನ್ನು ಏಕೆ ಚಿಂತೆ ಮಾಡಬೇಕು? ಆದರೆ ಸವಾಲು ಏಕೆಂದರೆ free() ಎಂದು ಅರ್ಥವಲ್ಲ ಮೆಮೊರಿ ಅಗತ್ಯವಾಗಿ ತಕ್ಷಣ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್‌ಗೆ ಮರಳುತ್ತದೆ.

ಮೆಮೊರಿ ವಿಘಟನೆಯಂತಹ ವಿಷಯವಿದೆ. ವಿಪರೀತ ಸಂದರ್ಭಗಳಲ್ಲಿ, ಕೆಲವು ಬೈಟ್‌ಗಳನ್ನು ಮಾತ್ರ ಬಳಸುವ ರಾಶಿ ವಿಭಾಗಗಳಿವೆ, ಆದರೆ ನಡುವೆ ಇರುವ ಎಲ್ಲವನ್ನೂ ಮುಕ್ತಗೊಳಿಸಲಾಗಿದೆ (free()).

ಮೆಮೊರಿ ವಿಘಟನೆಯು ವಿಸ್ಮಯಕಾರಿಯಾಗಿ ಸಂಕೀರ್ಣವಾದ ವಿಷಯವಾಗಿದೆ ಮತ್ತು ಪ್ರೋಗ್ರಾಂಗೆ ಸಣ್ಣ ಬದಲಾವಣೆಗಳು ಸಹ ಗಮನಾರ್ಹ ಪರಿಣಾಮವನ್ನು ಬೀರಬಹುದು ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಹೆಚ್ಚಿನ ಸಂದರ್ಭಗಳಲ್ಲಿ, ಪ್ರೋಗ್ರಾಂಗಳು ಗಮನಾರ್ಹವಾದ ಮೆಮೊರಿ ವಿಘಟನೆಗೆ ಕಾರಣವಾಗುವುದಿಲ್ಲ, ಆದರೆ ರಾಶಿಯ ಕೆಲವು ಪ್ರದೇಶದಲ್ಲಿ ವಿಘಟನೆಯ ಸಮಸ್ಯೆಯಿದ್ದರೆ, ಬೃಹತ್ ಪುಟಗಳು ಪರಿಸ್ಥಿತಿಯನ್ನು ಇನ್ನಷ್ಟು ಹದಗೆಡಿಸಬಹುದು ಎಂದು ನೀವು ತಿಳಿದಿರಬೇಕು.

ಬೃಹತ್ ಪುಟಗಳ ಆಯ್ದ ಬಳಕೆ

ಲೇಖನವನ್ನು ಓದಿದ ನಂತರ, ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂನ ಯಾವ ಭಾಗಗಳು ಬೃಹತ್ ಪುಟಗಳನ್ನು ಬಳಸುವುದರಿಂದ ಪ್ರಯೋಜನ ಪಡೆಯಬಹುದು ಮತ್ತು ಯಾವುದು ಸಾಧ್ಯವಿಲ್ಲ ಎಂಬುದನ್ನು ನೀವು ನಿರ್ಧರಿಸಿದ್ದೀರಿ. ಆದ್ದರಿಂದ ಬೃಹತ್ ಪುಟಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಬೇಕೇ?

ಅದೃಷ್ಟವಶಾತ್ ನೀವು ಬಳಸಬಹುದು madvise()ಇದು ಉಪಯುಕ್ತವಾಗಿರುವ ಮೆಮೊರಿಯ ಕ್ಷೇತ್ರಗಳಿಗೆ ಮಾತ್ರ ಬೃಹತ್ ಪೇಜಿಂಗ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲು.

ಮೊದಲಿಗೆ, ಬೃಹತ್ ಪುಟಗಳು ಮ್ಯಾಡ್‌ವೈಸ್ () ಮೋಡ್‌ನಲ್ಲಿ ರನ್ ಆಗುತ್ತಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ ಸೂಚನೆಗಳು ಲೇಖನದ ಆರಂಭದಲ್ಲಿ.

ನಂತರ, ಬಳಸಿ madvise()ಬೃಹತ್ ಪುಟಗಳನ್ನು ಎಲ್ಲಿ ಬಳಸಬೇಕೆಂದು ಕರ್ನಲ್‌ಗೆ ನಿಖರವಾಗಿ ಹೇಳಲು.

#include <sys/mman.h>
// Аллоцируйте большое количество памяти, которую будете использовать
size_t size = 256*1024*1024;
char* mymemory = malloc(size);
// Просто включите hugepages…
madvise(mymemory, size, MADV_HUGEPAGE);
// … и задайте следующее
madvise(mymemory, size, MADV_HUGEPAGE | MADV_SEQUENTIAL)

ಈ ವಿಧಾನವು ಮೆಮೊರಿಯನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುವುದು ಎಂಬುದರ ಕುರಿತು ಕರ್ನಲ್‌ಗೆ ಸರಳವಾಗಿ ಸಲಹೆಯಾಗಿದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ. ನಿರ್ದಿಷ್ಟ ಮೆಮೊರಿಗಾಗಿ ಕರ್ನಲ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಬೃಹತ್ ಪುಟಗಳನ್ನು ಬಳಸುತ್ತದೆ ಎಂದು ಇದರ ಅರ್ಥವಲ್ಲ.

ದಸ್ತಾವೇಜನ್ನು ನೋಡಿ (manpage) ಮಾಡ್ವೈಸ್ಮೆಮೊರಿ ನಿರ್ವಹಣೆಯ ಬಗ್ಗೆ ಇನ್ನಷ್ಟು ತಿಳಿದುಕೊಳ್ಳಲು ಮತ್ತು madvise(), ಈ ವಿಷಯವು ನಂಬಲಾಗದಷ್ಟು ಕಡಿದಾದ ಕಲಿಕೆಯ ರೇಖೆಯನ್ನು ಹೊಂದಿದೆ. ಆದ್ದರಿಂದ ನೀವು ಅದರಲ್ಲಿ ನಿಜವಾಗಿಯೂ ಉತ್ತಮವಾಗಲು ಬಯಸಿದರೆ, ನೀವು ಯಾವುದೇ ಸಕಾರಾತ್ಮಕ ಫಲಿತಾಂಶಗಳನ್ನು ನಿರೀಕ್ಷಿಸುವ ಮೊದಲು ಕೆಲವು ವಾರಗಳವರೆಗೆ ಓದಲು ಮತ್ತು ಪರೀಕ್ಷಿಸಲು ಸಿದ್ಧರಾಗಿರಿ.

ಏನು ಓದಬೇಕು?

ಪ್ರಶ್ನೆ ಇದೆಯೇ? ಕಾಮೆಂಟ್‌ಗಳಲ್ಲಿ ಬರೆಯಿರಿ!

ಮೂಲ: www.habr.com

ಬೃಹತ್ ಪುಟಗಳ ಅನುಕೂಲಗಳು ಮತ್ತು ಅನಾನುಕೂಲಗಳು