ਕੋਰਸ ਦੇ ਵਿਦਿਆਰਥੀਆਂ ਲਈ ਤਿਆਰ ਕੀਤੇ ਗਏ ਲੇਖ ਦਾ ਅਨੁਵਾਦ "ਲੀਨਕਸ ਪ੍ਰਸ਼ਾਸਕ".

ਪਹਿਲਾਂ, ਮੈਂ ਇਸ ਬਾਰੇ ਗੱਲ ਕੀਤੀ ਸੀ ਕਿ ਲੀਨਕਸ ਉੱਤੇ ਵਿਸ਼ਾਲ ਪੰਨਿਆਂ ਦੀ ਜਾਂਚ ਅਤੇ ਸਮਰੱਥ ਕਿਵੇਂ ਕਰੀਏ.
ਇਹ ਲੇਖ ਤਾਂ ਹੀ ਲਾਭਦਾਇਕ ਹੋਵੇਗਾ ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਅਸਲ ਵਿੱਚ ਵਿਸ਼ਾਲ ਪੰਨਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ ਜਗ੍ਹਾ ਹੈ। ਮੈਂ ਬਹੁਤ ਸਾਰੇ ਲੋਕਾਂ ਨੂੰ ਮਿਲਿਆ ਹਾਂ ਜੋ ਇਸ ਸੰਭਾਵਨਾ ਦੁਆਰਾ ਮੂਰਖ ਬਣਾਏ ਗਏ ਹਨ ਕਿ ਵਿਸ਼ਾਲਪੇਜ ਜਾਦੂਈ ਢੰਗ ਨਾਲ ਉਤਪਾਦਕਤਾ ਵਿੱਚ ਸੁਧਾਰ ਕਰਨਗੇ। ਹਾਲਾਂਕਿ, ਵਿਸ਼ਾਲ ਪੇਜਿੰਗ ਇੱਕ ਗੁੰਝਲਦਾਰ ਵਿਸ਼ਾ ਹੈ ਅਤੇ ਜੇਕਰ ਗਲਤ ਤਰੀਕੇ ਨਾਲ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਤਾਂ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਘਟਾ ਸਕਦਾ ਹੈ।

ਭਾਗ 1: ਤਸਦੀਕ ਕਰਨਾ ਕਿ ਵੱਡੇ ਪੰਨੇ ਲੀਨਕਸ (ਮੂਲ ਇੱਥੇ)

ਸਮੱਸਿਆ:
ਤੁਹਾਨੂੰ ਇਹ ਦੇਖਣ ਦੀ ਲੋੜ ਹੈ ਕਿ ਕੀ ਤੁਹਾਡੇ ਸਿਸਟਮ 'ਤੇ HugePages ਸਮਰਥਿਤ ਹੈ।

ਹੱਲ:
ਇਹ ਕਾਫ਼ੀ ਸਧਾਰਨ ਹੈ:

cat /sys/kernel/mm/transparent_hugepage/enabled

ਤੁਹਾਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਕੁਝ ਮਿਲੇਗਾ:

always [madvise] never

ਤੁਸੀਂ ਉਪਲਬਧ ਵਿਕਲਪਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਵੇਖੋਗੇ (ਹਮੇਸ਼ਾ, madvise, ਕਦੇ ਵੀ), ਅਤੇ ਵਰਤਮਾਨ ਵਿੱਚ ਕਿਰਿਆਸ਼ੀਲ ਵਿਕਲਪ ਨੂੰ ਬਰੈਕਟਾਂ ਵਿੱਚ ਨੱਥੀ ਕੀਤਾ ਜਾਵੇਗਾ (ਮੂਲ ਰੂਪ ਵਿੱਚ madvise).

madvise ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ transparent hugepages ਸਿਰਫ਼ ਮੈਮੋਰੀ ਖੇਤਰਾਂ ਲਈ ਯੋਗ ਕੀਤਾ ਗਿਆ ਹੈ ਜੋ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਵਿਸ਼ਾਲ ਪੰਨਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬੇਨਤੀ ਕਰਦੇ ਹਨ madvise(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

• madvise ਨੂੰ ਡਿਫੌਲਟ ਵਜੋਂ ਸੈਟ ਕਰਨ ਲਈ, ਵਰਤੋ:

  CONFIG_TRANSPARENT_HUGEPAGE_MADVISE=y
  # Comment out CONFIG_TRANSPARENT_HUGEPAGE_ALWAYS=y

ਭਾਗ 2: ਵੱਡੇ ਪੰਨਿਆਂ ਦੇ ਫਾਇਦੇ ਅਤੇ ਨੁਕਸਾਨ

ਅਸੀਂ ਵੱਡੇ ਪੰਨਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਫਾਇਦਿਆਂ, ਨੁਕਸਾਨਾਂ ਅਤੇ ਸੰਭਾਵਿਤ ਨੁਕਸਾਨਾਂ ਨੂੰ ਚੋਣਵੇਂ ਰੂਪ ਵਿੱਚ ਸਮਝਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਾਂਗੇ। ਕਿਉਂਕਿ ਇੱਕ ਤਕਨੀਕੀ ਤੌਰ 'ਤੇ ਗੁੰਝਲਦਾਰ ਅਤੇ ਪੈਡੈਂਟਿਕ ਲੇਖ ਉਹਨਾਂ ਲੋਕਾਂ ਲਈ ਸਮਝਣਾ ਮੁਸ਼ਕਲ ਹੋਵੇਗਾ ਜੋ ਇਹ ਸੋਚਣ ਵਿੱਚ ਭੁਲੇਖੇ ਵਿੱਚ ਹਨ ਕਿ ਵਿਸ਼ਾਲ ਪੰਨੇ ਇੱਕ ਇਲਾਜ ਹੈ, ਮੈਂ ਸਾਦਗੀ ਲਈ ਸ਼ੁੱਧਤਾ ਦਾ ਬਲੀਦਾਨ ਕਰਾਂਗਾ। ਇਹ ਧਿਆਨ ਵਿੱਚ ਰੱਖਣ ਯੋਗ ਹੈ ਕਿ ਬਹੁਤ ਸਾਰੇ ਵਿਸ਼ੇ ਅਸਲ ਵਿੱਚ ਗੁੰਝਲਦਾਰ ਹਨ ਅਤੇ ਇਸਲਈ ਬਹੁਤ ਸਰਲ ਹਨ।

ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਅਸੀਂ ਲੀਨਕਸ ਨੂੰ ਚਲਾਉਣ ਵਾਲੇ 64-ਬਿੱਟ x86 ਸਿਸਟਮਾਂ ਬਾਰੇ ਗੱਲ ਕਰ ਰਹੇ ਹਾਂ, ਅਤੇ ਇਹ ਕਿ ਮੈਂ ਸਿਰਫ਼ ਇਹ ਮੰਨ ਰਿਹਾ ਹਾਂ ਕਿ ਸਿਸਟਮ ਪਾਰਦਰਸ਼ੀ ਵਿਸ਼ਾਲ ਪੰਨਿਆਂ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ (ਕਿਉਂਕਿ ਇਹ ਕੋਈ ਨੁਕਸਾਨ ਨਹੀਂ ਹੈ ਕਿ ਵਿਸ਼ਾਲ ਪੰਨਿਆਂ ਨੂੰ ਓਵਰਰਾਈਟ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ), ਜਿਵੇਂ ਕਿ ਲਗਭਗ ਕਿਸੇ ਵੀ ਆਧੁਨਿਕ ਲੀਨਕਸ ਵਿੱਚ ਹੁੰਦਾ ਹੈ। ਵਾਤਾਵਰਣ.

ਮੈਂ ਹੇਠਾਂ ਦਿੱਤੇ ਲਿੰਕਾਂ ਵਿੱਚ ਹੋਰ ਤਕਨੀਕੀ ਵਰਣਨ ਨੱਥੀ ਕਰਾਂਗਾ।

ਵਰਚੁਅਲ ਮੈਮੋਰੀ

ਜੇ ਤੁਸੀਂ ਇੱਕ C++ ਪ੍ਰੋਗਰਾਮਰ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਜਾਣਦੇ ਹੋ ਕਿ ਮੈਮੋਰੀ ਵਿੱਚ ਵਸਤੂਆਂ ਦੇ ਖਾਸ ਪਤੇ (ਪੁਆਇੰਟਰ ਮੁੱਲ) ਹੁੰਦੇ ਹਨ।

ਹਾਲਾਂਕਿ, ਇਹ ਪਤੇ ਜ਼ਰੂਰੀ ਤੌਰ 'ਤੇ ਮੈਮੋਰੀ (RAM ਐਡਰੈੱਸ) ਵਿੱਚ ਭੌਤਿਕ ਪਤਿਆਂ ਨੂੰ ਦਰਸਾਉਂਦੇ ਨਹੀਂ ਹਨ। ਉਹ ਵਰਚੁਅਲ ਮੈਮੋਰੀ ਵਿੱਚ ਪਤਿਆਂ ਨੂੰ ਦਰਸਾਉਂਦੇ ਹਨ। ਪ੍ਰੋਸੈਸਰ ਕੋਲ ਇੱਕ ਵਿਸ਼ੇਸ਼ MMU (ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਯੂਨਿਟ) ਮੋਡੀਊਲ ਹੈ ਜੋ ਕਿ ਕਰਨਲ ਮੈਪ ਵਰਚੁਅਲ ਮੈਮੋਰੀ ਨੂੰ ਭੌਤਿਕ ਸਥਾਨ 'ਤੇ ਬਣਾਉਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ।

ਇਸ ਪਹੁੰਚ ਦੇ ਬਹੁਤ ਸਾਰੇ ਫਾਇਦੇ ਹਨ, ਪਰ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਹਨ:

• ਪ੍ਰਦਰਸ਼ਨ (ਵੱਖ-ਵੱਖ ਕਾਰਨਾਂ ਕਰਕੇ);
• ਪ੍ਰੋਗਰਾਮ ਆਈਸੋਲੇਸ਼ਨ, ਯਾਨੀ ਕੋਈ ਵੀ ਪ੍ਰੋਗਰਾਮ ਦੂਜੇ ਪ੍ਰੋਗਰਾਮ ਦੀ ਮੈਮੋਰੀ ਤੋਂ ਪੜ੍ਹ ਨਹੀਂ ਸਕਦਾ।

ਪੰਨੇ ਕੀ ਹਨ?

ਵਰਚੁਅਲ ਮੈਮੋਰੀ ਨੂੰ ਪੰਨਿਆਂ ਵਿੱਚ ਵੰਡਿਆ ਗਿਆ ਹੈ। ਹਰੇਕ ਵਿਅਕਤੀਗਤ ਪੰਨਾ ਇੱਕ ਖਾਸ ਭੌਤਿਕ ਮੈਮੋਰੀ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਦਾ ਹੈ, ਇਹ RAM ਵਿੱਚ ਇੱਕ ਖੇਤਰ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰ ਸਕਦਾ ਹੈ, ਜਾਂ ਇਹ ਇੱਕ ਭੌਤਿਕ ਡਿਵਾਈਸ, ਜਿਵੇਂ ਕਿ ਇੱਕ ਵੀਡੀਓ ਕਾਰਡ ਨੂੰ ਨਿਰਧਾਰਤ ਕੀਤੇ ਪਤੇ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰ ਸਕਦਾ ਹੈ।

ਜ਼ਿਆਦਾਤਰ ਪੰਨੇ ਜਿਨ੍ਹਾਂ ਨਾਲ ਤੁਸੀਂ ਡੀਲ ਕਰਦੇ ਹੋ ਜਾਂ ਤਾਂ ਰੈਮ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਦੇ ਹੋ ਜਾਂ ਬਦਲੇ ਜਾਂਦੇ ਹਨ, ਭਾਵ ਉਹ ਤੁਹਾਡੀ ਹਾਰਡ ਡਰਾਈਵ ਜਾਂ SSD 'ਤੇ ਸਟੋਰ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। ਕਰਨਲ ਹਰੇਕ ਪੰਨੇ ਦੇ ਭੌਤਿਕ ਖਾਕੇ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਇੱਕ ਨਕਲੀ ਪੰਨੇ ਤੱਕ ਪਹੁੰਚ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਕਰਨਲ ਉਸ ਥਰਿੱਡ ਨੂੰ ਰੋਕਦਾ ਹੈ ਜੋ ਮੈਮੋਰੀ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਿਹਾ ਹੈ, ਪੰਨੇ ਨੂੰ ਹਾਰਡ ਡਰਾਈਵ/SSD ਤੋਂ RAM ਵਿੱਚ ਪੜ੍ਹਦਾ ਹੈ, ਅਤੇ ਫਿਰ ਥਰਿੱਡ ਨੂੰ ਚਲਾਉਣਾ ਜਾਰੀ ਰੱਖਦਾ ਹੈ।

ਇਹ ਪ੍ਰਕਿਰਿਆ ਸਟ੍ਰੀਮ ਪਾਰਦਰਸ਼ੀ ਹੈ, ਮਤਲਬ ਕਿ ਇਹ ਜ਼ਰੂਰੀ ਨਹੀਂ ਹੈ ਕਿ ਇਹ ਸਿੱਧੇ HDD/SSD ਤੋਂ ਪੜ੍ਹੇ। ਆਮ ਪੰਨਿਆਂ ਦਾ ਆਕਾਰ 4096 ਬਾਈਟ ਹੈ। ਵੱਡੇ ਪੰਨਿਆਂ ਦਾ ਆਕਾਰ 2 ਮੈਗਾਬਾਈਟ ਹੈ।

ਟ੍ਰਾਂਸਲੇਸ਼ਨ-ਐਸੋਸੀਏਟਿਵ ਬਫਰ (TLB)

ਜਦੋਂ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਮੈਮੋਰੀ ਦੇ ਇੱਕ ਪੰਨੇ ਤੱਕ ਪਹੁੰਚ ਕਰਦਾ ਹੈ, ਤਾਂ CPU ਨੂੰ ਪਤਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਕਿਹੜੇ ਭੌਤਿਕ ਪੰਨੇ ਤੋਂ ਡੇਟਾ ਪੜ੍ਹਨਾ ਹੈ (ਭਾਵ, ਇੱਕ ਵਰਚੁਅਲ ਐਡਰੈੱਸ ਮੈਪ ਹੋਵੇ)।

ਕਰਨਲ ਵਿੱਚ ਇੱਕ ਡੇਟਾ ਢਾਂਚਾ (ਪੰਨਾ ਸਾਰਣੀ) ਹੁੰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਵਰਤੇ ਜਾ ਰਹੇ ਪੰਨਿਆਂ ਬਾਰੇ ਸਾਰੀ ਜਾਣਕਾਰੀ ਹੁੰਦੀ ਹੈ। ਇਸ ਡੇਟਾ ਢਾਂਚੇ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਤੁਸੀਂ ਇੱਕ ਵਰਚੁਅਲ ਪਤੇ ਨੂੰ ਇੱਕ ਭੌਤਿਕ ਪਤੇ ਨਾਲ ਮੈਪ ਕਰ ਸਕਦੇ ਹੋ।

ਹਾਲਾਂਕਿ, ਪੇਜ ਟੇਬਲ ਕਾਫ਼ੀ ਗੁੰਝਲਦਾਰ ਅਤੇ ਹੌਲੀ ਹੈ, ਇਸਲਈ ਅਸੀਂ ਹਰ ਵਾਰ ਜਦੋਂ ਕੋਈ ਪ੍ਰਕਿਰਿਆ ਮੈਮੋਰੀ ਤੱਕ ਪਹੁੰਚ ਕਰਦੀ ਹੈ ਤਾਂ ਅਸੀਂ ਪੂਰੇ ਡੇਟਾ ਢਾਂਚੇ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਨਹੀਂ ਕਰ ਸਕਦੇ ਹਾਂ।

ਖੁਸ਼ਕਿਸਮਤੀ ਨਾਲ, ਸਾਡੇ ਪ੍ਰੋਸੈਸਰ ਵਿੱਚ ਇੱਕ TLB ਹੈ ਜੋ ਵਰਚੁਅਲ ਅਤੇ ਭੌਤਿਕ ਪਤਿਆਂ ਵਿਚਕਾਰ ਮੈਪਿੰਗ ਨੂੰ ਕੈਸ਼ ਕਰਦਾ ਹੈ। ਇਸਦਾ ਮਤਲਬ ਇਹ ਹੈ ਕਿ ਹਾਲਾਂਕਿ ਸਾਨੂੰ ਪਹਿਲੀ ਐਕਸੈਸ ਕੋਸ਼ਿਸ਼ 'ਤੇ ਪੇਜ ਟੇਬਲ ਨੂੰ ਪਾਰਸ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਪੰਨੇ ਦੀਆਂ ਸਾਰੀਆਂ ਅਗਲੀਆਂ ਐਕਸੈਸਾਂ ਨੂੰ TLB ਵਿੱਚ ਹੈਂਡਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਤੇਜ਼ ਕਾਰਵਾਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।

ਕਿਉਂਕਿ ਇਹ ਇੱਕ ਭੌਤਿਕ ਯੰਤਰ ਵਜੋਂ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ (ਜੋ ਇਸਨੂੰ ਪਹਿਲੀ ਥਾਂ ਤੇ ਤੇਜ਼ ਬਣਾਉਂਦਾ ਹੈ), ਇਸਦੀ ਸਮਰੱਥਾ ਸੀਮਤ ਹੈ. ਇਸ ਲਈ ਜੇਕਰ ਤੁਸੀਂ ਹੋਰ ਪੰਨਿਆਂ ਤੱਕ ਪਹੁੰਚਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ TLB ਉਹਨਾਂ ਸਾਰਿਆਂ ਲਈ ਮੈਪਿੰਗ ਸਟੋਰ ਕਰਨ ਦੇ ਯੋਗ ਨਹੀਂ ਹੋਵੇਗਾ, ਜਿਸ ਨਾਲ ਤੁਹਾਡਾ ਪ੍ਰੋਗਰਾਮ ਬਹੁਤ ਹੌਲੀ ਚੱਲੇਗਾ।

ਵੱਡੇ ਪੰਨੇ ਬਚਾਅ ਲਈ ਆਉਂਦੇ ਹਨ

ਤਾਂ ਅਸੀਂ TLB ਓਵਰਫਲੋ ਤੋਂ ਬਚਣ ਲਈ ਕੀ ਕਰ ਸਕਦੇ ਹਾਂ? (ਅਸੀਂ ਮੰਨਦੇ ਹਾਂ ਕਿ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਅਜੇ ਵੀ ਉਸੇ ਮਾਤਰਾ ਦੀ ਮੈਮੋਰੀ ਦੀ ਲੋੜ ਹੈ)।

ਇਹ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ ਵਿਸ਼ਾਲ ਪੰਨੇ ਆਉਂਦੇ ਹਨ. 4096 ਬਾਈਟਾਂ ਦੀ ਬਜਾਏ ਸਿਰਫ਼ ਇੱਕ TLB ਇੰਦਰਾਜ਼ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਇੱਕ TLB ਐਂਟਰੀ ਹੁਣ 2 ਮੈਗਾਬਾਈਟ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰ ਸਕਦੀ ਹੈ। ਮੰਨ ਲਓ TLB ਦੀਆਂ 512 ਐਂਟਰੀਆਂ ਹਨ, ਇੱਥੇ ਵੱਡੇ ਪੰਨਿਆਂ ਤੋਂ ਬਿਨਾਂ ਅਸੀਂ ਮੇਲ ਕਰ ਸਕਦੇ ਹਾਂ:

4096 b⋅512=2 MB

ਫਿਰ ਅਸੀਂ ਉਹਨਾਂ ਨਾਲ ਕਿਵੇਂ ਤੁਲਨਾ ਕਰ ਸਕਦੇ ਹਾਂ:

2 MB⋅512=1 GB

ਇਹੀ ਕਾਰਨ ਹੈ ਕਿ ਵਿਸ਼ਾਲ ਪੰਨੇ ਸ਼ਾਨਦਾਰ ਹਨ। ਉਹ ਬਿਨਾਂ ਕਿਸੇ ਮਿਹਨਤ ਦੇ ਉਤਪਾਦਕਤਾ ਵਿੱਚ ਸੁਧਾਰ ਕਰ ਸਕਦੇ ਹਨ। ਪਰ ਇੱਥੇ ਮਹੱਤਵਪੂਰਨ ਚੇਤਾਵਨੀਆਂ ਹਨ.

ਵੱਡੇ ਪੰਨੇ ਸਪੂਫਿੰਗ

ਕਰਨਲ ਆਟੋਮੈਟਿਕ ਹੀ ਨਿਗਰਾਨੀ ਕਰਦਾ ਹੈ ਕਿ ਹਰੇਕ ਮੈਮੋਰੀ ਪੰਨੇ ਨੂੰ ਕਿੰਨੀ ਵਾਰ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਜੇਕਰ ਲੋੜੀਂਦੀ ਭੌਤਿਕ ਮੈਮੋਰੀ (RAM) ਨਹੀਂ ਹੈ, ਤਾਂ ਕਰਨਲ ਘੱਟ ਮਹੱਤਵਪੂਰਨ (ਘੱਟ ਅਕਸਰ ਵਰਤੇ ਜਾਣ ਵਾਲੇ) ਪੰਨਿਆਂ ਨੂੰ ਹਾਰਡ ਡਿਸਕ ਤੇ ਭੇਜਦਾ ਹੈ ਤਾਂ ਜੋ ਵਧੇਰੇ ਮਹੱਤਵਪੂਰਨ ਪੰਨਿਆਂ ਲਈ ਕੁਝ RAM ਖਾਲੀ ਕੀਤੀ ਜਾ ਸਕੇ।
ਸਿਧਾਂਤਕ ਤੌਰ 'ਤੇ, ਇਹੀ ਵੱਡੇ ਪੰਨਿਆਂ 'ਤੇ ਲਾਗੂ ਹੁੰਦਾ ਹੈ। ਹਾਲਾਂਕਿ, ਕਰਨਲ ਸਿਰਫ਼ ਪੂਰੇ ਪੰਨਿਆਂ ਨੂੰ ਸਵੈਪ ਕਰ ਸਕਦਾ ਹੈ, ਵਿਅਕਤੀਗਤ ਬਾਈਟਾਂ ਨੂੰ ਨਹੀਂ।

ਮੰਨ ਲਓ ਕਿ ਸਾਡੇ ਕੋਲ ਇਸ ਤਰ੍ਹਾਂ ਦਾ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਹੈ:

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

ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਕਰਨਲ ਨੂੰ ਤੁਹਾਡੇ ਇੱਕ ਬਾਈਟ ਨੂੰ ਪੜ੍ਹਨ ਲਈ ਹਾਰਡ ਡਰਾਈਵ/SSD ਤੋਂ 2 ਮੈਗਾਬਾਈਟ ਜਾਣਕਾਰੀ ਨੂੰ ਬਦਲਣ (ਪੜ੍ਹਨ) ਦੀ ਲੋੜ ਹੋਵੇਗੀ। ਜਿਵੇਂ ਕਿ ਨਿਯਮਤ ਪੰਨਿਆਂ ਲਈ, ਹਾਰਡ ਡਰਾਈਵ/SSD ਤੋਂ ਸਿਰਫ਼ 4096 ਬਾਈਟਾਂ ਨੂੰ ਪੜ੍ਹਨ ਦੀ ਲੋੜ ਹੈ।

ਇਸ ਲਈ, ਜੇਕਰ ਵਿਸ਼ਾਲ ਪੰਨੇ ਨੂੰ ਓਵਰਰਾਈਡ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਇਹ ਸਿਰਫ਼ ਪੜ੍ਹਨਾ ਤੇਜ਼ ਹੈ ਜੇਕਰ ਤੁਹਾਨੂੰ ਪੂਰੇ ਪੰਨੇ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਇਸਦਾ ਮਤਲਬ ਇਹ ਹੈ ਕਿ ਜੇਕਰ ਤੁਸੀਂ ਮੈਮੋਰੀ ਦੇ ਵੱਖ-ਵੱਖ ਹਿੱਸਿਆਂ ਨੂੰ ਬੇਤਰਤੀਬ ਢੰਗ ਨਾਲ ਐਕਸੈਸ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਹੇ ਹੋ ਅਤੇ ਸਿਰਫ ਕੁਝ ਕਿਲੋਬਾਈਟ ਪੜ੍ਹ ਰਹੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਨਿਯਮਤ ਪੰਨਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ ਅਤੇ ਕਿਸੇ ਹੋਰ ਚੀਜ਼ ਬਾਰੇ ਚਿੰਤਾ ਨਹੀਂ ਕਰਨੀ ਚਾਹੀਦੀ।

ਦੂਜੇ ਪਾਸੇ, ਜੇਕਰ ਤੁਹਾਨੂੰ ਮੈਮੋਰੀ ਦੇ ਇੱਕ ਵੱਡੇ ਹਿੱਸੇ ਨੂੰ ਕ੍ਰਮਵਾਰ ਐਕਸੈਸ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਵਿਸ਼ਾਲ ਪੰਨੇ ਤੁਹਾਡੀ ਕਾਰਗੁਜ਼ਾਰੀ ਵਿੱਚ ਸੁਧਾਰ ਕਰਨਗੇ। ਹਾਲਾਂਕਿ, ਤੁਹਾਨੂੰ ਇਸਦੀ ਖੁਦ ਜਾਂਚ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ (ਐਬਸਟਰੈਕਟ ਸੌਫਟਵੇਅਰ ਨਾਲ ਨਹੀਂ) ਅਤੇ ਦੇਖੋ ਕਿ ਕੀ ਤੇਜ਼ੀ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ।

ਮੈਮੋਰੀ ਵਿੱਚ ਵੰਡ

ਜੇ ਤੁਸੀਂ C ਲਿਖਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਜਾਣਦੇ ਹੋ ਕਿ ਤੁਸੀਂ ਢੇਰ ਤੋਂ ਮਨਮਾਨੇ ਤੌਰ 'ਤੇ ਛੋਟੀ (ਜਾਂ ਲਗਭਗ ਮਨਮਰਜ਼ੀ ਨਾਲ ਵੱਡੀ) ਮਾਤਰਾ ਦੀ ਮੈਮੋਰੀ ਲਈ ਬੇਨਤੀ ਕਰ ਸਕਦੇ ਹੋ malloc(). ਮੰਨ ਲਓ ਕਿ ਤੁਹਾਨੂੰ 30 ਬਾਈਟ ਮੈਮੋਰੀ ਦੀ ਲੋੜ ਹੈ:

char* mymemory = malloc(30);

ਇੱਕ ਪ੍ਰੋਗਰਾਮਰ ਨੂੰ, ਇਹ ਜਾਪਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਤੋਂ 30 ਬਾਈਟ ਮੈਮੋਰੀ ਦੀ "ਬੇਨਤੀ" ਕਰ ਰਹੇ ਹੋ ਅਤੇ ਕੁਝ ਵਰਚੁਅਲ ਮੈਮੋਰੀ ਲਈ ਇੱਕ ਪੁਆਇੰਟਰ ਵਾਪਸ ਕਰ ਰਹੇ ਹੋ। ਪਰ ਅਸਲ ਵਿੱਚ malloc () ਸਿਰਫ਼ ਇੱਕ C ਫੰਕਸ਼ਨ ਹੈ ਜੋ ਫੰਕਸ਼ਨ ਦੇ ਅੰਦਰੋਂ ਕਾਲ ਕਰਦਾ ਹੈ brk ਅਤੇ sbrk ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਤੋਂ ਮੈਮੋਰੀ ਦੀ ਬੇਨਤੀ ਜਾਂ ਮੁਫਤ ਕਰਨ ਲਈ।

ਹਾਲਾਂਕਿ, ਹਰੇਕ ਵੰਡ ਲਈ ਵੱਧ ਤੋਂ ਵੱਧ ਮੈਮੋਰੀ ਦੀ ਬੇਨਤੀ ਕਰਨਾ ਅਯੋਗ ਹੈ; ਇਹ ਸਭ ਤੋਂ ਵੱਧ ਸੰਭਾਵਨਾ ਹੈ ਕਿ ਕੁਝ ਮੈਮੋਰੀ ਖੰਡ ਪਹਿਲਾਂ ਹੀ ਮੁਕਤ ਕੀਤਾ ਗਿਆ ਹੈ (free()), ਅਤੇ ਅਸੀਂ ਇਸਨੂੰ ਦੁਬਾਰਾ ਵਰਤ ਸਕਦੇ ਹਾਂ। malloc() ਫ੍ਰੀਡ ਮੈਮੋਰੀ ਦੀ ਮੁੜ ਵਰਤੋਂ ਕਰਨ ਲਈ ਕਾਫ਼ੀ ਗੁੰਝਲਦਾਰ ਐਲਗੋਰਿਦਮ ਲਾਗੂ ਕਰਦਾ ਹੈ।

ਉਸੇ ਸਮੇਂ, ਤੁਹਾਡੇ ਲਈ ਸਭ ਕੁਝ ਅਣਜਾਣ ਵਾਪਰਦਾ ਹੈ, ਇਸ ਲਈ ਤੁਹਾਨੂੰ ਚਿੰਤਾ ਕਿਉਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ? ਪਰ ਕਿਉਂਕਿ ਚੁਣੌਤੀ ਹੈ free() ਇਸ ਦਾ ਮਤਲਬ ਇਹ ਨਹੀਂ ਹੈ ਮੈਮੋਰੀ ਜ਼ਰੂਰੀ ਤੌਰ 'ਤੇ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਨੂੰ ਤੁਰੰਤ ਵਾਪਸ ਕੀਤੀ ਜਾਂਦੀ ਹੈ.

ਮੈਮੋਰੀ ਫਰੈਗਮੈਂਟੇਸ਼ਨ ਵਰਗੀ ਇੱਕ ਚੀਜ਼ ਹੈ. ਅਤਿਅੰਤ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਢੇਰ ਦੇ ਹਿੱਸੇ ਹੁੰਦੇ ਹਨ ਜਿੱਥੇ ਸਿਰਫ ਕੁਝ ਬਾਈਟਾਂ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜਦੋਂ ਕਿ ਵਿਚਕਾਰਲੀ ਹਰ ਚੀਜ਼ ਨੂੰ ਮੁਕਤ ਕਰ ਦਿੱਤਾ ਗਿਆ ਹੈ (free()).

ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਮੈਮੋਰੀ ਫਰੈਗਮੈਂਟੇਸ਼ਨ ਇੱਕ ਬਹੁਤ ਹੀ ਗੁੰਝਲਦਾਰ ਵਿਸ਼ਾ ਹੈ, ਅਤੇ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਮਾਮੂਲੀ ਤਬਦੀਲੀਆਂ ਵੀ ਮਹੱਤਵਪੂਰਣ ਪ੍ਰਭਾਵ ਪਾ ਸਕਦੀਆਂ ਹਨ। ਜ਼ਿਆਦਾਤਰ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਪ੍ਰੋਗਰਾਮ ਮਹੱਤਵਪੂਰਨ ਮੈਮੋਰੀ ਫ੍ਰੈਗਮੈਂਟੇਸ਼ਨ ਦਾ ਕਾਰਨ ਨਹੀਂ ਬਣਦੇ, ਪਰ ਤੁਹਾਨੂੰ ਇਹ ਸੁਚੇਤ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਜੇਕਰ ਢੇਰ ਦੇ ਕੁਝ ਖੇਤਰ ਵਿੱਚ ਫ੍ਰੈਗਮੈਂਟੇਸ਼ਨ ਵਿੱਚ ਕੋਈ ਸਮੱਸਿਆ ਹੈ, ਤਾਂ ਵਿਸ਼ਾਲ ਪੰਨੇ ਸਥਿਤੀ ਨੂੰ ਵਿਗੜ ਸਕਦੇ ਹਨ।

ਵਿਸ਼ਾਲ ਪੰਨਿਆਂ ਦੀ ਚੋਣਵੀਂ ਵਰਤੋਂ

ਇਸ ਲੇਖ ਨੂੰ ਪੜ੍ਹਨ ਤੋਂ ਬਾਅਦ, ਤੁਸੀਂ ਇਹ ਨਿਰਧਾਰਤ ਕੀਤਾ ਹੈ ਕਿ ਤੁਹਾਡੇ ਪ੍ਰੋਗਰਾਮ ਦੇ ਕਿਹੜੇ ਹਿੱਸੇ ਵੱਡੇ ਪੰਨਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਨਾਲ ਲਾਭ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹਨ ਅਤੇ ਕਿਹੜੇ ਨਹੀਂ ਹੋ ਸਕਦੇ। ਤਾਂ ਕੀ ਵੱਡੇ ਪੰਨੇ ਬਿਲਕੁਲ ਸਮਰੱਥ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ?

ਖੁਸ਼ਕਿਸਮਤੀ ਨਾਲ ਤੁਸੀਂ ਵਰਤ ਸਕਦੇ ਹੋ madvise()ਸਿਰਫ ਉਹਨਾਂ ਮੈਮੋਰੀ ਖੇਤਰਾਂ ਲਈ ਵਿਸ਼ਾਲ ਪੇਜਿੰਗ ਨੂੰ ਸਮਰੱਥ ਕਰਨ ਲਈ ਜਿੱਥੇ ਇਹ ਲਾਭਦਾਇਕ ਹੋਵੇਗਾ।

ਪਹਿਲਾਂ, ਜਾਂਚ ਕਰੋ ਕਿ ਵਿਸ਼ਾਲ ਪੰਨੇ 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ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਬਾਰੇ ਹੋਰ ਜਾਣਨ ਲਈ ਅਤੇ madvise(), ਇਸ ਵਿਸ਼ੇ ਵਿੱਚ ਇੱਕ ਬਹੁਤ ਹੀ ਤੇਜ਼ ਸਿੱਖਣ ਦੀ ਵਕਰ ਹੈ। ਇਸ ਲਈ ਜੇਕਰ ਤੁਸੀਂ ਇਸ ਵਿੱਚ ਸੱਚਮੁੱਚ ਚੰਗਾ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਕਿਸੇ ਵੀ ਸਕਾਰਾਤਮਕ ਨਤੀਜਿਆਂ ਦੀ ਉਮੀਦ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਕੁਝ ਹਫ਼ਤਿਆਂ ਲਈ ਪੜ੍ਹਨ ਅਤੇ ਟੈਸਟ ਕਰਨ ਲਈ ਤਿਆਰ ਰਹੋ।

ਕੀ ਪੜ੍ਹਨਾ ਹੈ?

• ਵਿਸ਼ਾਲ ਪੰਨਿਆਂ 'ਤੇ IBM ਓਪਨਸਟੈਕ ਲੇਖ
• ਪਾਰਦਰਸ਼ੀ ਵਿਸ਼ਾਲ ਪੰਨੇ ਬਨਾਮ ਗੈਰ-ਪਾਰਦਰਸ਼ੀ ਵਿਸ਼ਾਲ ਪੰਨੇ
• TLB ਬਾਰੇ ਵਿਕੀਪੀਡੀਆ ਲੇਖ
• ਪਾਰਦਰਸ਼ੀ ਵਿਸ਼ਾਲ ਪੰਨਿਆਂ 'ਤੇ ਲੀਨਕਸ ਕਰਨਲ ਦਸਤਾਵੇਜ਼
• ਸਟੈਕਓਵਰਫਲੋ: ਵਿਸ਼ਾਲ ਪੰਨੇ ਮੈਮੋਰੀ ਫਰੈਗਮੈਂਟੇਸ਼ਨ ਦਾ ਸ਼ਿਕਾਰ ਹੁੰਦੇ ਹਨ
• ਵਰਚੁਅਲ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ 'ਤੇ ਮਾਈਕ੍ਰੋਸਾੱਫਟ ਲੇਖ

ਕੋਈ ਸਵਾਲ ਹੈ? ਟਿੱਪਣੀਆਂ ਵਿੱਚ ਲਿਖੋ!

ਸਰੋਤ: www.habr.com