ਚੋਰੀ: ਜੋ ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਤੋਂ ਪ੍ਰੋਸੈਸਰ ਦਾ ਸਮਾਂ ਚੋਰੀ ਕਰਦਾ ਹੈ

ਸਤ ਸ੍ਰੀ ਅਕਾਲ! ਮੈਂ ਤੁਹਾਨੂੰ ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਦੇ ਅੰਦਰ ਚੋਰੀ ਕਰਨ ਦੇ ਮਕੈਨਿਕਸ ਬਾਰੇ ਅਤੇ ਕੁਝ ਗੈਰ-ਸਪੱਸ਼ਟ ਕਲਾਤਮਕ ਚੀਜ਼ਾਂ ਬਾਰੇ ਦੱਸਣਾ ਚਾਹੁੰਦਾ ਹਾਂ ਜੋ ਅਸੀਂ ਇਸਦੀ ਖੋਜ ਦੌਰਾਨ ਖੋਜਣ ਵਿੱਚ ਕਾਮਯਾਬ ਹੋਏ, ਜਿਸ ਵਿੱਚ ਮੈਨੂੰ ਇੱਕ ਕਲਾਉਡ ਪਲੇਟਫਾਰਮ ਦੇ ਤਕਨੀਕੀ ਨਿਰਦੇਸ਼ਕ ਦੇ ਰੂਪ ਵਿੱਚ ਡੁਬਕੀ ਕਰਨੀ ਪਈ। Mail.ru ਕਲਾਉਡ ਹੱਲ. ਪਲੇਟਫਾਰਮ KVM 'ਤੇ ਚੱਲਦਾ ਹੈ।

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

1. ਚੋਰੀ ਕੀ ਹੈ

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

ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਕਰਨਲ ਹਾਈਪਰਵਾਈਜ਼ਰ ਤੋਂ ਚੋਰੀ ਮੈਟ੍ਰਿਕ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ। ਇਸ ਦੇ ਨਾਲ ਹੀ, ਹਾਈਪਰਵਾਈਜ਼ਰ ਇਹ ਨਹੀਂ ਦੱਸਦਾ ਕਿ ਇਹ ਕਿਹੜੀਆਂ ਹੋਰ ਪ੍ਰਕਿਰਿਆਵਾਂ ਚੱਲ ਰਿਹਾ ਹੈ, ਇਹ ਸਿਰਫ਼ ਕਹਿੰਦਾ ਹੈ "ਜਦੋਂ ਮੈਂ ਰੁੱਝਿਆ ਹੋਇਆ ਹਾਂ, ਮੈਂ ਤੁਹਾਨੂੰ ਸਮਾਂ ਨਹੀਂ ਦੇ ਸਕਦਾ।" KVM ਉੱਤੇ, ਸਟੀਲ ਕੈਲਕੂਲੇਸ਼ਨ ਲਈ ਸਹਿਯੋਗ ਜੋੜਿਆ ਗਿਆ ਹੈ ਪੈਚ. ਇੱਥੇ ਦੋ ਮੁੱਖ ਨੁਕਤੇ ਹਨ:

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

2. ਚੋਰੀ ਨੂੰ ਕੀ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ

2.1 ਹਿਸਾਬ ਚੋਰੀ ਕਰੋ

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

• ਪ੍ਰੋਸੈਸਰ ਜ਼ਿਆਦਾ ਗਰਮ ਹੋ ਜਾਂਦਾ ਹੈ, ਜਿਸ ਕਾਰਨ ਚੱਕਰ ਛੱਡੇ ਜਾਂਦੇ ਹਨ।
• ਟਰਬੋ ਬੂਸਟ ਨੂੰ ਸਮਰੱਥ/ਅਯੋਗ ਕਰੋ, ਜੋ ਪ੍ਰੋਸੈਸਰ ਦੀ ਘੜੀ ਦੀ ਬਾਰੰਬਾਰਤਾ ਨੂੰ ਬਦਲਦਾ ਹੈ।
• ਸਮੇਂ ਦੇ ਟੁਕੜੇ ਦੀ ਲੰਬਾਈ ਵਿੱਚ ਇੱਕ ਤਬਦੀਲੀ ਜੋ ਪ੍ਰੋਸੈਸਰ ਪਾਵਰ-ਸੇਵਿੰਗ ਤਕਨੀਕਾਂ ਜਿਵੇਂ ਕਿ ਸਪੀਡਸਟੈਪ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ ਵਾਪਰਦੀ ਹੈ।
• ਔਸਤ ਦੀ ਗਣਨਾ ਕਰਨ ਵਿੱਚ ਸਮੱਸਿਆ: 80% 'ਤੇ ਇੱਕ ਮਿੰਟ ਦੀ ਉਪਯੋਗਤਾ ਦਾ ਅੰਦਾਜ਼ਾ ਲਗਾਉਣਾ 100% ਦੀ ਇੱਕ ਛੋਟੀ ਮਿਆਦ ਦੇ ਬਰਸਟ ਨੂੰ ਲੁਕਾ ਸਕਦਾ ਹੈ।
• ਇੱਕ ਸਪਿਨ ਲਾਕ ਪ੍ਰੋਸੈਸਰ ਨੂੰ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਨ ਦਾ ਕਾਰਨ ਬਣਦਾ ਹੈ, ਪਰ ਉਪਭੋਗਤਾ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਇਸਦੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਵਿੱਚ ਕੋਈ ਪ੍ਰਗਤੀ ਨਹੀਂ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ। ਨਤੀਜੇ ਵਜੋਂ, ਪ੍ਰਕਿਰਿਆ ਦੁਆਰਾ ਗਣਿਤ ਪ੍ਰੋਸੈਸਰ ਦੀ ਵਰਤੋਂ ਸੌ ਪ੍ਰਤੀਸ਼ਤ ਹੋਵੇਗੀ, ਹਾਲਾਂਕਿ ਪ੍ਰਕਿਰਿਆ ਸਰੀਰਕ ਤੌਰ 'ਤੇ ਪ੍ਰੋਸੈਸਰ ਸਮੇਂ ਦੀ ਖਪਤ ਨਹੀਂ ਕਰੇਗੀ।

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

ਚੋਰੀ ਦੀ ਗਿਣਤੀ ਪ੍ਰਕਿਰਿਆ ਨਿਯਮਤ ਰੀਸਾਈਕਲਿੰਗ ਕਾਉਂਟਿੰਗ ਵਰਗੀਆਂ ਸਮੱਸਿਆਵਾਂ ਦੇ ਅਧੀਨ ਹੈ। ਇਹ ਕਹਿਣ ਲਈ ਨਹੀਂ ਕਿ ਅਜਿਹੀਆਂ ਸਮੱਸਿਆਵਾਂ ਅਕਸਰ ਦਿਖਾਈ ਦਿੰਦੀਆਂ ਹਨ, ਪਰ ਇਹ ਨਿਰਾਸ਼ਾਜਨਕ ਲੱਗਦੀਆਂ ਹਨ।

2.2 KVM ਉੱਤੇ ਵਰਚੁਅਲਾਈਜੇਸ਼ਨ ਦੀਆਂ ਕਿਸਮਾਂ

ਮੋਟੇ ਤੌਰ 'ਤੇ, ਵਰਚੁਅਲਾਈਜੇਸ਼ਨ ਦੀਆਂ ਤਿੰਨ ਕਿਸਮਾਂ ਹਨ, ਜੋ ਕਿ KVM ਦੁਆਰਾ ਸਮਰਥਿਤ ਹਨ। ਚੋਰੀ ਹੋਣ ਦੀ ਵਿਧੀ ਵਰਚੁਅਲਾਈਜੇਸ਼ਨ ਦੀ ਕਿਸਮ 'ਤੇ ਨਿਰਭਰ ਕਰ ਸਕਦੀ ਹੈ।

ਪ੍ਰਸਾਰਣ. ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਭੌਤਿਕ ਹਾਈਪਰਵਾਈਜ਼ਰ ਡਿਵਾਈਸਾਂ ਦੇ ਨਾਲ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦਾ ਸੰਚਾਲਨ ਕੁਝ ਇਸ ਤਰ੍ਹਾਂ ਹੁੰਦਾ ਹੈ:

1. ਗਿਸਟ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਆਪਣੇ ਗੈਸਟ ਜੰਤਰ ਨੂੰ ਇੱਕ ਕਮਾਂਡ ਭੇਜਦਾ ਹੈ।
2. ਗੈਸਟ ਜੰਤਰ ਡਰਾਈਵਰ ਕਮਾਂਡ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ, ਜੰਤਰ BIOS ਲਈ ਇੱਕ ਬੇਨਤੀ ਤਿਆਰ ਕਰਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਹਾਈਪਰਵਾਈਜ਼ਰ ਨੂੰ ਭੇਜਦਾ ਹੈ।
3. ਹਾਈਪਰਵਾਈਜ਼ਰ ਪ੍ਰਕਿਰਿਆ ਭੌਤਿਕ ਯੰਤਰ ਲਈ ਕਮਾਂਡ ਤੋਂ ਕਮਾਂਡ ਦਾ ਅਨੁਵਾਦ ਕਰਦੀ ਹੈ, ਇਸ ਨੂੰ ਹੋਰ ਚੀਜ਼ਾਂ ਦੇ ਨਾਲ, ਵਧੇਰੇ ਸੁਰੱਖਿਅਤ ਬਣਾਉਂਦੀ ਹੈ।
4. ਭੌਤਿਕ ਜੰਤਰ ਡਰਾਈਵਰ ਸੋਧਿਆ ਹੁਕਮ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ ਅਤੇ ਇਸ ਨੂੰ ਭੌਤਿਕ ਜੰਤਰ ਨੂੰ ਆਪਣੇ ਆਪ ਨੂੰ ਭੇਜਦਾ ਹੈ.
5. ਕਮਾਂਡਾਂ ਨੂੰ ਚਲਾਉਣ ਦੇ ਨਤੀਜੇ ਉਸੇ ਮਾਰਗ 'ਤੇ ਵਾਪਸ ਜਾਂਦੇ ਹਨ।

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

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

ਪੈਰਾਵਰਚੁਅਲਾਈਜੇਸ਼ਨ. KVM ਉੱਤੇ ਜੰਤਰ ਵਰਚੁਅਲਾਈਜੇਸ਼ਨ ਲਈ ਸਭ ਤੋਂ ਆਮ ਵਿਕਲਪ ਅਤੇ ਆਮ ਤੌਰ 'ਤੇ ਗਿਸਟ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮਾਂ ਲਈ ਸਭ ਤੋਂ ਆਮ ਵਰਚੁਅਲਾਈਜੇਸ਼ਨ ਮੋਡ। ਇਸਦੀ ਵਿਸ਼ੇਸ਼ਤਾ ਇਹ ਹੈ ਕਿ ਕੁਝ ਹਾਈਪਰਵਾਈਜ਼ਰ ਸਬ-ਸਿਸਟਮ (ਉਦਾਹਰਨ ਲਈ, ਨੈੱਟਵਰਕ ਜਾਂ ਡਿਸਕ ਸਟੈਕ ਨਾਲ) ਜਾਂ ਮੈਮੋਰੀ ਪੰਨਿਆਂ ਦੀ ਵੰਡ ਹਾਈਪਰਵਾਈਜ਼ਰ API ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਹੇਠਲੇ-ਪੱਧਰ ਦੀਆਂ ਕਮਾਂਡਾਂ ਦਾ ਅਨੁਵਾਦ ਕੀਤੇ ਬਿਨਾਂ ਹੁੰਦੀ ਹੈ। ਇਸ ਵਰਚੁਅਲਾਈਜੇਸ਼ਨ ਵਿਧੀ ਦਾ ਨੁਕਸਾਨ ਇਹ ਹੈ ਕਿ ਗੈਸਟ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਕਰਨਲ ਨੂੰ ਸੋਧਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਤਾਂ ਜੋ ਇਹ ਇਸ API ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਹਾਈਪਰਵਾਈਜ਼ਰ ਨਾਲ ਸੰਚਾਰ ਕਰ ਸਕੇ। ਪਰ ਇਹ ਆਮ ਤੌਰ 'ਤੇ ਗੈਸਟ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ 'ਤੇ ਵਿਸ਼ੇਸ਼ ਡਰਾਈਵਰਾਂ ਨੂੰ ਸਥਾਪਿਤ ਕਰਕੇ ਹੱਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। KVM ਵਿੱਚ ਇਸ API ਨੂੰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ virtio API.

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

ਇਸ ਪ੍ਰਵੇਗ ਦਾ ਨਨੁਕਸਾਨ ਇਹ ਹੈ ਕਿ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਦੇ ਅੰਦਰ ਚੱਲਣ ਵਾਲੀਆਂ ਸਾਰੀਆਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਇਸਦੇ ਅੰਦਰ ਨਹੀਂ ਰਹਿੰਦੀਆਂ। ਇਹ ਕੁਝ ਖਾਸ ਪ੍ਰਭਾਵ ਪੈਦਾ ਕਰਦਾ ਹੈ ਜਿਸ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਚੋਰੀ 'ਤੇ ਸਪੋਨ ਹੋ ਸਕਦੇ ਹਨ। ਮੈਂ ਨਾਲ ਇਸ ਮੁੱਦੇ ਦਾ ਵਿਸਤ੍ਰਿਤ ਅਧਿਐਨ ਸ਼ੁਰੂ ਕਰਨ ਦੀ ਸਿਫਾਰਸ਼ ਕਰਦਾ ਹਾਂ ਵਰਚੁਅਲ I/O ਲਈ ਇੱਕ API: virtio.

2.3 "ਨਿਰਪੱਖ" ਸਮਾਂ-ਸਾਰਣੀ

ਹਾਈਪਰਵਾਈਜ਼ਰ 'ਤੇ ਇੱਕ ਵਰਚੁਅਲ ਮਸ਼ੀਨ, ਅਸਲ ਵਿੱਚ, ਇੱਕ ਆਮ ਪ੍ਰਕਿਰਿਆ ਹੈ ਜੋ ਲੀਨਕਸ ਕਰਨਲ ਵਿੱਚ ਸਮਾਂ-ਸਾਰਣੀ (ਪ੍ਰਕਿਰਿਆਵਾਂ ਵਿਚਕਾਰ ਸਰੋਤ ਵੰਡ) ਦੇ ਨਿਯਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰਦੀ ਹੈ, ਇਸ ਲਈ ਆਓ ਇਸ 'ਤੇ ਇੱਕ ਡੂੰਘਾਈ ਨਾਲ ਵਿਚਾਰ ਕਰੀਏ।

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

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

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

ਇੱਕ ਤੱਥ ਨੂੰ ਸਮਝਾਉਣ ਲਈ ਇੰਨੀ ਲੰਮੀ ਕਹਾਣੀ ਦੀ ਲੋੜ ਹੈ: ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਇੱਕ ਇਮਾਨਦਾਰ ਲੀਨਕਸ ਸ਼ਡਿਊਲਰ ਵਿੱਚ ਜਿੰਨਾ ਜ਼ਿਆਦਾ ਪ੍ਰੋਸੈਸਰ ਸਰੋਤਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੀ ਹੈ, ਓਨੀ ਹੀ ਤੇਜ਼ੀ ਨਾਲ ਇਸਨੂੰ ਰੋਕਿਆ ਜਾਵੇਗਾ ਤਾਂ ਜੋ ਹੋਰ ਪ੍ਰਕਿਰਿਆਵਾਂ ਵੀ ਕੰਮ ਕਰ ਸਕਣ। ਕੀ ਇਹ ਸਹੀ ਹੈ ਜਾਂ ਨਹੀਂ, ਇਹ ਇੱਕ ਗੁੰਝਲਦਾਰ ਸਵਾਲ ਹੈ ਜੋ ਵੱਖੋ-ਵੱਖਰੇ ਬੋਝ ਹੇਠ ਵੱਖਰੇ ਢੰਗ ਨਾਲ ਹੱਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਵਿੰਡੋਜ਼ ਵਿੱਚ, ਹਾਲ ਹੀ ਵਿੱਚ, ਸ਼ਡਿਊਲਰ ਡੈਸਕਟੌਪ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੀ ਤਰਜੀਹੀ ਪ੍ਰਕਿਰਿਆ 'ਤੇ ਕੇਂਦ੍ਰਿਤ ਸੀ, ਜਿਸ ਨਾਲ ਬੈਕਗ੍ਰਾਉਂਡ ਪ੍ਰਕਿਰਿਆਵਾਂ ਫ੍ਰੀਜ਼ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਸਨ ਸੋਲਾਰਿਸ ਕੋਲ ਸ਼ਡਿਊਲਰ ਦੀਆਂ ਪੰਜ ਵੱਖ-ਵੱਖ ਸ਼੍ਰੇਣੀਆਂ ਸਨ। ਜਦੋਂ ਅਸੀਂ ਵਰਚੁਅਲਾਈਜੇਸ਼ਨ ਲਾਂਚ ਕੀਤਾ, ਅਸੀਂ ਛੇਵਾਂ ਜੋੜਿਆ, ਨਿਰਪੱਖ ਸ਼ੇਅਰ ਸ਼ਡਿਊਲਰ, ਕਿਉਂਕਿ ਪਿਛਲੇ ਪੰਜਾਂ ਨੇ ਸੋਲਾਰਿਸ ਜ਼ੋਨ ਵਰਚੁਅਲਾਈਜੇਸ਼ਨ ਨਾਲ ਢੁਕਵੇਂ ਢੰਗ ਨਾਲ ਕੰਮ ਨਹੀਂ ਕੀਤਾ। ਮੈਂ ਕਿਤਾਬਾਂ ਨਾਲ ਇਸ ਮੁੱਦੇ ਦਾ ਵਿਸਤ੍ਰਿਤ ਅਧਿਐਨ ਸ਼ੁਰੂ ਕਰਨ ਦੀ ਸਿਫਾਰਸ਼ ਕਰਦਾ ਹਾਂ ਸੋਲਾਰਿਸ ਇੰਟਰਨਲ: ਸੋਲਾਰਿਸ 10 ਅਤੇ ਓਪਨਸੋਲਾਰਿਸ ਕਰਨਲ ਆਰਕੀਟੈਕਚਰ ਜ ਲੀਨਕਸ ਕਰਨਲ ਨੂੰ ਸਮਝਣਾ.

2.4 ਚੋਰੀ ਦੀ ਨਿਗਰਾਨੀ ਕਿਵੇਂ ਕਰੀਏ?

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

ਟਾਪ ਕਮਾਂਡ ਦਾ ਆਉਟਪੁੱਟ: ਪ੍ਰੋਸੈਸਰ ਲੋਡ ਦਾ ਵੇਰਵਾ, ਸਭ ਤੋਂ ਸੱਜੇ ਕਾਲਮ ਵਿੱਚ - ਚੋਰੀ

ਹਾਈਪਰਵਾਈਜ਼ਰ ਤੋਂ ਇਹ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਸਮੇਂ ਮੁਸ਼ਕਲ ਪੈਦਾ ਹੁੰਦੀ ਹੈ। ਤੁਸੀਂ ਹੋਸਟ ਮਸ਼ੀਨ 'ਤੇ ਚੋਰੀ ਦੀ ਭਵਿੱਖਬਾਣੀ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਸਕਦੇ ਹੋ, ਉਦਾਹਰਨ ਲਈ, ਲੋਡ ਔਸਤ (LA) ਪੈਰਾਮੀਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ - ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਕਤਾਰ ਵਿੱਚ ਉਡੀਕ ਕਰ ਰਹੀਆਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਦੀ ਗਿਣਤੀ ਦਾ ਔਸਤ ਮੁੱਲ। ਇਸ ਪੈਰਾਮੀਟਰ ਦੀ ਗਣਨਾ ਕਰਨ ਦਾ ਤਰੀਕਾ ਸਧਾਰਨ ਨਹੀਂ ਹੈ, ਪਰ ਆਮ ਤੌਰ 'ਤੇ, ਜੇ LA ਨੂੰ ਪ੍ਰੋਸੈਸਰ ਥਰਿੱਡਾਂ ਦੀ ਸੰਖਿਆ ਦੁਆਰਾ ਸਾਧਾਰਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ 1 ਤੋਂ ਵੱਧ ਹੈ, ਤਾਂ ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਲੀਨਕਸ ਸਰਵਰ ਕਿਸੇ ਚੀਜ਼ ਨਾਲ ਓਵਰਲੋਡ ਹੈ।

ਇਹ ਸਾਰੀਆਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਕਿਸ ਦੀ ਉਡੀਕ ਕਰ ਰਹੀਆਂ ਹਨ? ਸਪੱਸ਼ਟ ਜਵਾਬ ਪ੍ਰੋਸੈਸਰ ਹੈ. ਪਰ ਜਵਾਬ ਪੂਰੀ ਤਰ੍ਹਾਂ ਸਹੀ ਨਹੀਂ ਹੈ, ਕਿਉਂਕਿ ਕਈ ਵਾਰ ਪ੍ਰੋਸੈਸਰ ਮੁਫਤ ਹੁੰਦਾ ਹੈ, ਪਰ ਐਲਏ ਪੈਮਾਨੇ ਤੋਂ ਬਾਹਰ ਜਾਂਦਾ ਹੈ। ਯਾਦ ਰੱਖਣਾ NFS ਕਿਵੇਂ ਡਿੱਗਦਾ ਹੈ ਅਤੇ LA ਕਿਵੇਂ ਵਧਦਾ ਹੈ. ਇਹੀ ਇੱਕ ਡਿਸਕ ਅਤੇ ਹੋਰ ਇਨਪੁਟ/ਆਊਟਪੁੱਟ ਡਿਵਾਈਸਾਂ ਨਾਲ ਹੋ ਸਕਦਾ ਹੈ। ਪਰ ਅਸਲ ਵਿੱਚ, ਪ੍ਰਕਿਰਿਆਵਾਂ ਕਿਸੇ ਵੀ ਲਾਕ ਦੇ ਅੰਤ ਦੀ ਉਡੀਕ ਕਰ ਸਕਦੀਆਂ ਹਨ, ਜਾਂ ਤਾਂ ਭੌਤਿਕ, ਇੱਕ I/O ਡਿਵਾਈਸ ਨਾਲ ਸੰਬੰਧਿਤ, ਜਾਂ ਲਾਜ਼ੀਕਲ, ਜਿਵੇਂ ਕਿ ਇੱਕ ਮਿਊਟੇਕਸ। ਇਸ ਵਿੱਚ ਹਾਰਡਵੇਅਰ ਦੇ ਪੱਧਰ (ਡਿਸਕ ਤੋਂ ਉਹੀ ਜਵਾਬ), ਜਾਂ ਤਰਕ (ਅਖੌਤੀ ਲਾਕਿੰਗ ਪ੍ਰਾਈਮਿਟਿਵਜ਼, ਜਿਸ ਵਿੱਚ ਇਕਾਈਆਂ ਦਾ ਇੱਕ ਸਮੂਹ, ਮਿਊਟੈਕਸ ਅਡੈਪਟਿਵ ਅਤੇ ਸਪਿਨ, ਸੇਮਫੋਰਸ, ਕੰਡੀਸ਼ਨ ਵੇਰੀਏਬਲ, ਆਰਡਬਲਯੂ ਲਾਕ, ਆਈਪੀਸੀ ਲਾਕ ਸ਼ਾਮਲ ਹਨ) ਦੇ ਪੱਧਰ 'ਤੇ ਲਾਕ ਕਰਨਾ ਵੀ ਸ਼ਾਮਲ ਹੈ। ...)।

LA ਦੀ ਇੱਕ ਹੋਰ ਵਿਸ਼ੇਸ਼ਤਾ ਇਹ ਹੈ ਕਿ ਇਸਨੂੰ ਇੱਕ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਔਸਤ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, 100 ਪ੍ਰਕਿਰਿਆਵਾਂ ਇੱਕ ਫਾਈਲ ਲਈ ਮੁਕਾਬਲਾ ਕਰ ਰਹੀਆਂ ਹਨ, ਅਤੇ ਫਿਰ LA=50। ਇੰਨਾ ਵੱਡਾ ਮੁੱਲ ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਖਰਾਬ ਹੈ। ਪਰ ਦੂਜੇ ਟੇਢੇ ਢੰਗ ਨਾਲ ਲਿਖੇ ਕੋਡ ਲਈ, ਇਹ ਇੱਕ ਆਮ ਸਥਿਤੀ ਹੋ ਸਕਦੀ ਹੈ, ਇਸ ਤੱਥ ਦੇ ਬਾਵਜੂਦ ਕਿ ਇਹ ਸਿਰਫ ਖਰਾਬ ਹੈ, ਅਤੇ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਵਿੱਚ ਹੋਰ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਨੁਕਸਾਨ ਨਹੀਂ ਹੁੰਦਾ.

ਇਸ ਔਸਤ (ਅਤੇ ਇੱਕ ਮਿੰਟ ਤੋਂ ਘੱਟ ਸਮੇਂ ਵਿੱਚ) ਦੇ ਕਾਰਨ, LA ਸੂਚਕ ਦੁਆਰਾ ਕਿਸੇ ਵੀ ਚੀਜ਼ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨਾ ਸਭ ਤੋਂ ਵੱਧ ਫਲਦਾਇਕ ਕੰਮ ਨਹੀਂ ਹੈ, ਖਾਸ ਮਾਮਲਿਆਂ ਵਿੱਚ ਬਹੁਤ ਹੀ ਅਨਿਸ਼ਚਿਤ ਨਤੀਜਿਆਂ ਦੇ ਨਾਲ। ਜੇਕਰ ਤੁਸੀਂ ਇਸਦਾ ਪਤਾ ਲਗਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਦੇਖੋਗੇ ਕਿ ਵਿਕੀਪੀਡੀਆ ਅਤੇ ਹੋਰ ਉਪਲਬਧ ਸਰੋਤਾਂ 'ਤੇ ਲੇਖ ਪ੍ਰਕਿਰਿਆ ਦੀ ਡੂੰਘੀ ਵਿਆਖਿਆ ਤੋਂ ਬਿਨਾਂ, ਸਿਰਫ ਸਧਾਰਨ ਮਾਮਲਿਆਂ ਦਾ ਵਰਣਨ ਕਰਦੇ ਹਨ। ਮੈਂ ਹਰ ਇੱਕ ਨੂੰ ਭੇਜਦਾ ਹਾਂ ਜੋ ਦਿਲਚਸਪੀ ਰੱਖਦਾ ਹੈ, ਦੁਬਾਰਾ, ਇੱਥੇ ਬ੍ਰੈਂਡਨ ਗ੍ਰੇਗ ਨੂੰ  - ਹੇਠਾਂ ਦਿੱਤੇ ਲਿੰਕਾਂ ਦੀ ਪਾਲਣਾ ਕਰੋ. ਕੌਣ ਅੰਗਰੇਜ਼ੀ ਬੋਲਣ ਵਿੱਚ ਬਹੁਤ ਆਲਸੀ ਹੈ - LA ਬਾਰੇ ਉਸਦੇ ਪ੍ਰਸਿੱਧ ਲੇਖ ਦਾ ਅਨੁਵਾਦ.

3. ਵਿਸ਼ੇਸ਼ ਪ੍ਰਭਾਵ

ਆਓ ਹੁਣ ਚੋਰੀ ਦੇ ਮੁੱਖ ਮਾਮਲਿਆਂ 'ਤੇ ਨਜ਼ਰ ਮਾਰੀਏ ਜਿਨ੍ਹਾਂ ਦਾ ਅਸੀਂ ਸਾਹਮਣਾ ਕੀਤਾ। ਮੈਂ ਤੁਹਾਨੂੰ ਦੱਸਾਂਗਾ ਕਿ ਉਹ ਉਪਰੋਕਤ ਸਭ ਤੋਂ ਕਿਵੇਂ ਪਾਲਣਾ ਕਰਦੇ ਹਨ ਅਤੇ ਉਹ ਹਾਈਪਰਵਾਈਜ਼ਰ 'ਤੇ ਸੂਚਕਾਂ ਨਾਲ ਕਿਵੇਂ ਸਬੰਧਤ ਹਨ।

ਰੀਸਾਈਕਲਿੰਗ. ਸਭ ਤੋਂ ਸਰਲ ਅਤੇ ਸਭ ਤੋਂ ਆਮ: ਹਾਈਪਰਵਾਈਜ਼ਰ ਦੀ ਮੁੜ ਵਰਤੋਂ ਕੀਤੀ ਗਈ ਹੈ। ਦਰਅਸਲ, ਇੱਥੇ ਬਹੁਤ ਸਾਰੀਆਂ ਚੱਲ ਰਹੀਆਂ ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਹਨ, ਉਹਨਾਂ ਦੇ ਅੰਦਰ ਉੱਚ ਪ੍ਰੋਸੈਸਰ ਦੀ ਖਪਤ, ਬਹੁਤ ਸਾਰਾ ਮੁਕਾਬਲਾ, LA ਉਪਯੋਗਤਾ 1 ਤੋਂ ਵੱਧ ਹੈ (ਪ੍ਰੋਸੈਸਰ ਥਰਿੱਡਾਂ ਦੁਆਰਾ ਸਧਾਰਣ)। ਸਾਰੀਆਂ ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਦੇ ਅੰਦਰ ਹਰ ਚੀਜ਼ ਹੌਲੀ ਹੋ ਜਾਂਦੀ ਹੈ। ਹਾਈਪਰਵਾਈਜ਼ਰ ਤੋਂ ਪ੍ਰਸਾਰਿਤ ਕੀਤੀ ਗਈ ਚੋਰੀ ਵੀ ਵਧ ਰਹੀ ਹੈ, ਲੋਡ ਨੂੰ ਮੁੜ ਵੰਡਣਾ ਜਾਂ ਕਿਸੇ ਨੂੰ ਬੰਦ ਕਰਨਾ ਜ਼ਰੂਰੀ ਹੈ. ਆਮ ਤੌਰ 'ਤੇ, ਹਰ ਚੀਜ਼ ਲਾਜ਼ੀਕਲ ਅਤੇ ਸਮਝਣ ਯੋਗ ਹੈ.

ਪੈਰਾਵਰਚੁਅਲਾਈਜੇਸ਼ਨ ਬਨਾਮ ਸਿੰਗਲ ਉਦਾਹਰਨਾਂ. ਹਾਈਪਰਵਾਈਜ਼ਰ 'ਤੇ ਸਿਰਫ ਇੱਕ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਹੈ; ਇਹ ਇਸਦੇ ਇੱਕ ਛੋਟੇ ਹਿੱਸੇ ਦੀ ਖਪਤ ਕਰਦੀ ਹੈ, ਪਰ ਇੱਕ ਵੱਡਾ I/O ਲੋਡ ਪੈਦਾ ਕਰਦੀ ਹੈ, ਉਦਾਹਰਨ ਲਈ ਡਿਸਕ 'ਤੇ। ਅਤੇ ਕਿਤੇ ਤੋਂ ਇਸ ਵਿੱਚ ਇੱਕ ਛੋਟੀ ਜਿਹੀ ਚੋਰੀ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ, 10% ਤੱਕ (ਜਿਵੇਂ ਕਿ ਕਈ ਪ੍ਰਯੋਗਾਂ ਦੁਆਰਾ ਦਿਖਾਇਆ ਗਿਆ ਹੈ)।

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

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

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

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

ਘੱਟ LA, ਪਰ ਉੱਥੇ ਚੋਰੀ ਹੈ. ਜੇ LA ਲਗਭਗ 0,7 ਹੈ (ਭਾਵ, ਹਾਈਪਰਵਾਈਜ਼ਰ ਅੰਡਰਲੋਡ ਕੀਤਾ ਜਾਪਦਾ ਹੈ), ਪਰ ਵਿਅਕਤੀਗਤ ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਦੇ ਅੰਦਰ ਚੋਰੀ ਦੇਖੀ ਜਾਂਦੀ ਹੈ:

• ਪੈਰਾਵਰਚੁਅਲਾਈਜੇਸ਼ਨ ਵਾਲਾ ਵਿਕਲਪ ਪਹਿਲਾਂ ਹੀ ਉੱਪਰ ਦੱਸਿਆ ਗਿਆ ਹੈ। ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਚੋਰੀ ਨੂੰ ਦਰਸਾਉਣ ਵਾਲੇ ਮੈਟ੍ਰਿਕਸ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੀ ਹੈ, ਹਾਲਾਂਕਿ ਹਾਈਪਰਵਾਈਜ਼ਰ ਠੀਕ ਹੈ। ਸਾਡੇ ਪ੍ਰਯੋਗਾਂ ਦੇ ਨਤੀਜਿਆਂ ਦੇ ਅਨੁਸਾਰ, ਇਹ ਚੋਰੀ ਵਿਕਲਪ 10% ਤੋਂ ਵੱਧ ਨਹੀਂ ਹੈ ਅਤੇ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਦੇ ਅੰਦਰ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੇ ਪ੍ਰਦਰਸ਼ਨ 'ਤੇ ਮਹੱਤਵਪੂਰਨ ਪ੍ਰਭਾਵ ਨਹੀਂ ਪਾਉਣਾ ਚਾਹੀਦਾ ਹੈ।
• LA ਪੈਰਾਮੀਟਰ ਦੀ ਗਣਨਾ ਗਲਤ ਹੈ। ਵਧੇਰੇ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ, ਹਰੇਕ ਖਾਸ ਪਲ 'ਤੇ ਇਸਦੀ ਸਹੀ ਗਣਨਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਪਰ ਜਦੋਂ ਇੱਕ ਮਿੰਟ ਤੋਂ ਵੱਧ ਔਸਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਤਾਂ ਇਹ ਘੱਟ ਅਨੁਮਾਨਿਤ ਹੁੰਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਹਾਈਪਰਵਾਈਜ਼ਰ ਦੇ ਪ੍ਰਤੀ ਤਿਹਾਈ ਇੱਕ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਆਪਣੇ ਸਾਰੇ ਪ੍ਰੋਸੈਸਰਾਂ ਨੂੰ ਬਿਲਕੁਲ ਅੱਧੇ ਮਿੰਟ ਲਈ ਵਰਤਦੀ ਹੈ, ਤਾਂ ਹਾਈਪਰਵਾਈਜ਼ਰ 'ਤੇ LA ਪ੍ਰਤੀ ਮਿੰਟ 0,15 ਹੋਵੇਗਾ; ਇੱਕੋ ਸਮੇਂ ਕੰਮ ਕਰਨ ਵਾਲੀਆਂ ਚਾਰ ਅਜਿਹੀਆਂ ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ 0,6 ਦੇਣਗੀਆਂ। ਅਤੇ ਇਹ ਤੱਥ ਕਿ ਉਹਨਾਂ ਵਿੱਚੋਂ ਹਰੇਕ 'ਤੇ ਅੱਧੇ ਮਿੰਟ ਲਈ 25% 'ਤੇ LA ਸੰਕੇਤਕ ਦੇ ਅਨੁਸਾਰ ਇੱਕ ਜੰਗਲੀ ਚੋਰੀ ਸੀ ਹੁਣ ਬਾਹਰ ਕੱਢਿਆ ਨਹੀਂ ਜਾ ਸਕਦਾ.
• ਦੁਬਾਰਾ ਫਿਰ, ਸ਼ਡਿਊਲਰ ਦੇ ਕਾਰਨ ਜਿਸ ਨੇ ਫੈਸਲਾ ਕੀਤਾ ਕਿ ਕੋਈ ਬਹੁਤ ਜ਼ਿਆਦਾ ਖਾ ਰਿਹਾ ਹੈ ਅਤੇ ਕਿਸੇ ਨੂੰ ਉਡੀਕ ਕਰਨ ਦਿਓ. ਇਸ ਦੌਰਾਨ, ਮੈਂ ਸੰਦਰਭ ਨੂੰ ਬਦਲਾਂਗਾ, ਰੁਕਾਵਟਾਂ ਨੂੰ ਸੰਭਾਲਾਂਗਾ ਅਤੇ ਹੋਰ ਮਹੱਤਵਪੂਰਨ ਸਿਸਟਮ ਚੀਜ਼ਾਂ ਦਾ ਧਿਆਨ ਰੱਖਾਂਗਾ। ਨਤੀਜੇ ਵਜੋਂ, ਕੁਝ ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਵਿੱਚ ਕੋਈ ਸਮੱਸਿਆ ਨਹੀਂ ਦਿਖਾਈ ਦਿੰਦੀ, ਜਦੋਂ ਕਿ ਹੋਰਾਂ ਨੂੰ ਕਾਰਗੁਜ਼ਾਰੀ ਵਿੱਚ ਗੰਭੀਰ ਗਿਰਾਵਟ ਦਾ ਅਨੁਭਵ ਹੁੰਦਾ ਹੈ।

4. ਹੋਰ ਵਿਗਾੜ

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

ਤਕਨੀਕਾਂ ਜਿਵੇਂ ਕਿ ਟਰਬੋ ਬੂਸਟ ਜਾਂ, ਇਸਦੇ ਉਲਟ, ਊਰਜਾ ਬਚਤ ਮੋਡ ਦੇ ਕਾਰਨ ਵਿਗਾੜ ਹਨ, ਜੋ ਉਪਯੋਗਤਾ ਦੀ ਗਣਨਾ ਕਰਦੇ ਸਮੇਂ, ਸਰਵਰ 'ਤੇ ਵਾਰਵਾਰਤਾ ਜਾਂ ਇੱਥੋਂ ਤੱਕ ਕਿ ਸਮੇਂ ਦੇ ਟੁਕੜੇ ਨੂੰ ਨਕਲੀ ਤੌਰ 'ਤੇ ਵਧਾ ਜਾਂ ਘਟਾ ਸਕਦੇ ਹਨ। ਟਰਬੋ ਬੂਸਟ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਣਾ ਦੂਜੇ ਪ੍ਰੋਸੈਸਰ ਦੇ ਪ੍ਰਦਰਸ਼ਨ ਵਿੱਚ ਵਾਧੇ ਦੇ ਕਾਰਨ ਇੱਕ ਪ੍ਰੋਸੈਸਰ ਥਰਿੱਡ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ। ਇਸ ਸਮੇਂ, ਮੌਜੂਦਾ ਪ੍ਰੋਸੈਸਰ ਦੀ ਬਾਰੰਬਾਰਤਾ ਬਾਰੇ ਜਾਣਕਾਰੀ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਨੂੰ ਪ੍ਰਸਾਰਿਤ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਅਤੇ ਇਹ ਵਿਸ਼ਵਾਸ ਕਰਦਾ ਹੈ ਕਿ ਕੋਈ ਵਿਅਕਤੀ ਇਸਦਾ ਸਮਾਂ ਚੋਰੀ ਕਰ ਰਿਹਾ ਹੈ (ਉਦਾਹਰਣ ਵਜੋਂ, ਇਸਨੇ 2 GHz ਦੀ ਬੇਨਤੀ ਕੀਤੀ, ਪਰ ਅੱਧਾ ਪ੍ਰਾਪਤ ਕੀਤਾ).

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

5. ਸਿੱਟਾ

1. ਪੈਰਾਵਰਚੁਅਲਾਈਜੇਸ਼ਨ ਦੇ ਕਾਰਨ ਕੁਝ ਮਾਤਰਾ ਵਿੱਚ ਚੋਰੀ ਹੋ ਸਕਦੀ ਹੈ, ਅਤੇ ਇਸਨੂੰ ਆਮ ਮੰਨਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਉਹ ਇੰਟਰਨੈੱਟ 'ਤੇ ਲਿਖਦੇ ਹਨ ਕਿ ਇਹ ਮੁੱਲ 5-10% ਹੋ ਸਕਦਾ ਹੈ. ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਦੇ ਅੰਦਰਲੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਅਤੇ ਇਸ ਦੇ ਭੌਤਿਕ ਡਿਵਾਈਸਾਂ 'ਤੇ ਲੋਡ ਕਰਨ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। ਇੱਥੇ ਇਹ ਧਿਆਨ ਦੇਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਦੇ ਅੰਦਰ ਕਿਵੇਂ ਮਹਿਸੂਸ ਕਰਦੀਆਂ ਹਨ।
2. ਹਾਈਪਰਵਾਈਜ਼ਰ 'ਤੇ ਲੋਡ ਦਾ ਅਨੁਪਾਤ ਅਤੇ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਦੇ ਅੰਦਰ ਚੋਰੀ ਹਮੇਸ਼ਾ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਆਪਸ ਵਿੱਚ ਨਹੀਂ ਹੁੰਦੇ ਹਨ; ਚੋਰੀ ਦੇ ਦੋਵੇਂ ਅਨੁਮਾਨ ਵੱਖ-ਵੱਖ ਲੋਡਾਂ ਦੇ ਅਧੀਨ ਖਾਸ ਸਥਿਤੀਆਂ ਵਿੱਚ ਗਲਤ ਹੋ ਸਕਦੇ ਹਨ।
3. ਸ਼ਡਿਊਲਰ ਦਾ ਉਹਨਾਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਪ੍ਰਤੀ ਬੁਰਾ ਰਵੱਈਆ ਹੈ ਜੋ ਬਹੁਤ ਕੁਝ ਪੁੱਛਦੀਆਂ ਹਨ। ਉਹ ਉਨ੍ਹਾਂ ਨੂੰ ਘੱਟ ਦੇਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ ਜੋ ਜ਼ਿਆਦਾ ਮੰਗਦੇ ਹਨ। ਵੱਡੀਆਂ ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਬੁਰਾਈਆਂ ਹਨ।
4. ਪੈਰਾਵਰਚੁਅਲਾਈਜ਼ੇਸ਼ਨ ਦੇ ਬਿਨਾਂ ਵੀ ਥੋੜੀ ਜਿਹੀ ਚੋਰੀ ਆਮ ਹੋ ਸਕਦੀ ਹੈ (ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਦੇ ਅੰਦਰ ਲੋਡ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਦੇ ਹੋਏ, ਗੁਆਂਢੀਆਂ ਦੇ ਲੋਡ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ, ਥਰਿੱਡਾਂ ਵਿੱਚ ਲੋਡ ਵੰਡ ਅਤੇ ਹੋਰ ਕਾਰਕਾਂ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਦੇ ਹੋਏ)।
5. ਜੇਕਰ ਤੁਸੀਂ ਕਿਸੇ ਖਾਸ ਸਿਸਟਮ ਵਿੱਚ ਚੋਰੀ ਦਾ ਪਤਾ ਲਗਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਵੱਖ-ਵੱਖ ਵਿਕਲਪਾਂ ਦੀ ਪੜਚੋਲ ਕਰਨੀ ਪਵੇਗੀ, ਮੈਟ੍ਰਿਕਸ ਇਕੱਠੇ ਕਰਨੇ ਪੈਣਗੇ, ਉਹਨਾਂ ਦਾ ਧਿਆਨ ਨਾਲ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨਾ ਹੋਵੇਗਾ ਅਤੇ ਲੋਡ ਨੂੰ ਸਮਾਨ ਰੂਪ ਵਿੱਚ ਵੰਡਣ ਬਾਰੇ ਸੋਚਣਾ ਹੋਵੇਗਾ। ਕਿਸੇ ਵੀ ਕੇਸ ਤੋਂ ਭਟਕਣਾ ਸੰਭਵ ਹੈ, ਜਿਸ ਦੀ ਤਜਰਬੇ ਨਾਲ ਪੁਸ਼ਟੀ ਕੀਤੀ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ ਜਾਂ ਕਰਨਲ ਡੀਬਗਰ ਵਿੱਚ ਦੇਖਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।

ਸਰੋਤ: www.habr.com