ਕਿਵੇਂ C ਅਤੇ C++ ਅਜੇ ਵੀ OS, ਡੇਟਾਬੇਸ ਅਤੇ ਗੇਮ ਇੰਜਣਾਂ ਨੂੰ ਚਲਾਉਂਦੇ ਹਨ

ਪਿਛੋਕੜ ਵਿੱਚ C ਅਤੇ C++ ਕਿਉਂ ਅਹੰਕਾਰ ਰੱਖਦੇ ਹਨ

“ਹੇਠਲੇ ਹਿੱਸੇ” ਉਹ ਸਭ ਕੁਝ ਹੈ ਜਿਸ 'ਤੇ ਤੁਹਾਡੀ ਐਪ ਨਿਰਭਰ ਕਰਦੀ ਹੈ ਪਰ ਜੋ ਅਕਸਰ ਸਿੱਧਾ ਹੱਥ ਨਹੀਂ ਲਗਦੀ: ਆਪਰੇਟਿੰਗ ਸਿਸਟਮ ਕਰਨਲ, ਡਿਵਾਈਸ ਡਰਾਇਵਰ, ਡੇਟਾਬੇਸ ਸਟੋਰੇਜ ਇੰਜਣ, ਨੈਟਵਰਕਿੰਗ ਸਟੈੱਕ, ਰਨਟਾਈਮਸ ਅਤੇ ਪ੍ਰਦਰਸ਼ਨ-ਨਾਜ਼ੁਕ ਲਾਇਬ੍ਰੇਰੀਆਂ।

ਇਸਦੇ ਉਲਟ, ਜਿਹੜੇ ਬਹੁਤ ਸਾਰੇ ਐਪ ਡਿਵੈਲਪਰ ਹਰ ਰੋਜ਼ ਦੇਖਦੇ ਹਨ ਉਹ ਸਤਹ ਹਨ: ਫਰੇਮਵਰਕ, APIs, ਮੈਨੇਜਡ ਰਨਟਾਈਮ, ਪੈਕੇਜ ਮੈਨੇਜਰ ਅਤੇ ਕਲਾਉਡ ਸਰਵਿਸਿਜ਼। ਇਹ ਲੇਅਰਸ ਸੁਰੱਖਿਅਤ ਅਤੇ ਉਤਪੀੜਕਤਾ-ਕੇਂਦ੍ਰਿਤ ਬਣਾਏ ਜਾਂਦੇ ਹਨ—ਭਾਵੇਂ ਕਿ ਉਹ ਜਾਣਬੂਝ ਕੇ ਜਟਿਲਤਾ ਨੂੰ ਛੁਪਾਉਂਦੇ ਹਨ।

ਕਿਉਂ ਕੁਝ ਲੇਅਰਾਂ ਨੂੰ ਹਾਰਡਵੇਅਰ ਦੇ ਨੇੜੇ ਰਹਿਣਾ ਪੈਂਦਾ ਹੈ

ਕੁਝ ਸਾਫਟਵੇਅਰ ਕੰਪੋਨੇਟਾਂ ਦੀਆਂ ਮੰਗਾਂ ਐਸੀਆਂ ਹੁੰਦੀਆਂ ਹਨ ਜੋ ਬਿਨਾਂ ਸਿੱਧੇ ਕੰਟਰੋਲ ਦੇ ਪੂਰੀਆਂ ਕਰਨੀ ਮੁਸ਼ਕਿਲ ਹੁੰਦੀਆਂ ਹਨ:

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

ਇੱਥੇ C ਅਤੇ C++ ਹੁਣ ਵੀ ਆਮ ਹਨ ਕਿਉਂਕਿ ਉਹ ਘੱਟ ਤੋਂ ਘੱਟ ਰਨਟਾਈਮ ਓਵਰਹੈੱਡ ਨਾਲ ਨੇਟਿਵ ਕੋਡ ਵਿੱਚ ਕੰਪਾਇਲ ਹੁੰਦੇ ਹਨ ਅਤੇ ਇੰਜੀਨੀਅਰਾਂ ਨੂੰ ਮੇਮੋਰੀ ਅਤੇ ਸਿਸਟਮ ਕਾਲਜ਼ ਉਤੇ ਬਰੀਕ ਕੰਟਰੋਲ ਦਿੰਦੇ ਹਨ।

ਅੱਜ ਕਿੱਥੇ C ਅਤੇ C++ ਸਭ ਤੋਂ ਵੱਧ ਮਿਲਦੇ ਹਨ

ਉੱਚ-ਸਤਹ ਤੇ ਤੁਸੀਂ C ਅਤੇ C++ ਨੂੰ ਇਹਨਾਂ ਥਾਵਾਂ ਤੇ ਪਾਓਗੇ:

• ਆਪਰੇਟਿੰਗ ਸਿਸਟਮ ਕੋਰ ਅਤੇ ਨੀਵੀਂ-ਸਤਹ ਲਾਇਬ੍ਰੇਰੀਆਂ
• ਡਰਾਈਵਰ ਅਤੇ ਐਮਬੈੱਡਿਡ ਫਰਮਵੇਅਰ
• ਡੇਟਾਬੇਸ ਇੰਜਣ (ਕੁਐਰੀ ਐਕਜ਼ਿਕਿਊਸ਼ਨ, ਸਟੋਰੇਜ, ਇੰਡੈਕਸਿੰਗ)
• ਗੇਮ ਇੰਜਣ ਅਤੇ ਰੀਅਲ-ਟਾਈਮ ਸਬਸਿਸਟਮ (ਰੇਂਡਰਿੰਗ, ਫ਼ਿਜ਼ਿਕਸ, ਆਡੀਓ)
• ਕੰਪਾਇਲਰ, ਟੂਲਚੇਨ ਅਤੇ ਭਾਸ਼ਾ ਰਨਟਾਈਮ ਜਿਸ 'ਤੇ ਹੋਰ ਭਾਸ਼ਾਵਾਂ ਨਿਰਭਰ ਹਨ

ਇਹ ਪੋਸਟ ਕੀ ਕਵਰ ਕਰੇਗੀ (ਅਤੇ ਕੀ ਨਹੀਂ)

ਇਹ ਲੇਖ ਤਕਨੀਕੀ ਮਕੈਨਿਕਸ 'ਤੇ ਧਿਆਨ ਦੇਵੇਗਾ: ਉਹ "ਹੇਠਲੇ ਹਿੱਸੇ" ਕੀ ਕਰਦੇ ਹਨ, ਕਿ ਉਹਨਾਂ ਨੂੰ ਨੇਟਿਵ ਕੋਡ کیوں ਫ਼ਾਇਦਾ ਦਿੰਦਾ ਹੈ, ਅਤੇ ਉਨ੍ਹਾਂ ਨਾਲ ਜੁੜੇ ਟਰੇਡ-ਆਫ਼ ਕੀ ਹਨ।

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

ਸਿਸਟਮ ਸਾਫਟਵੇਅਰ ਲਈ C ਅਤੇ C++ ਨੂੰ ਕਿਹੜਾ ਫਾਇਦਾ ਹੈ

C ਅਤੇ C++ ਨੂੰ ਸਿਸਟਮ ਸਾਫਟਵੇਅਰ ਵਿੱਚ ਵਿਆਪਕ ਤੌਰ 'ਤੇ ਇਸ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਕਿਉਂਕਿ ਇਹ "ਮੈਟਲ ਦੇ ਨੇੜੇ" ਪ੍ਰੋਗਰਾਮ ਬਣਾਉਂਦੇ ਹਨ: ਛੋਟੇ, ਤੇਜ਼, ਅਤੇ OS ਤੇ ਹਾਰਡਵੇਅਰ ਨਾਲ ਘਣਿਸ਼ਠ ਤੌਰ 'ਤੇ ਇੰਟਿਗ੍ਰੇਟ ਕੀਤੇ ਹੋਏ।

ਨੇਟਿਵ ਕੋਡ ਵਿੱਚ ਕੰਪਾਇਲ ਹੋਣਾ (ਸਧਾਰਨ ਭਾਸ਼ਾ)

ਜਦੋਂ C/C++ ਕੋਡ ਕੰਪਾਈਲ ਹੁੰਦਾ ਹੈ, ਉਹ CPU ਵੱਲੋਂ ਸਿੱਧਾ ਚਲਾਏ ਜਾਣ ਵਾਲੇ ਮਸ਼ੀਨ ਨਿਰਦੇਸ਼ਾਂ ਵਿੱਚ ਬਦਲ ਜਾਂਦਾ ਹੈ। ਕਿਸੇ ਰਨਟਾਈਮ ਦੀ ਲੋੜ ਨਹੀਂ ਹੁੰਦੀ ਜੋ ਚਲਦੇ ਸਮੇਂ ਨਿਰਦੇਸ਼ਾਂ ਦਾ ਅਨੁਵਾਦ ਕਰੇ।

ਇਹ ਕੇਰ ਉਦਯੋਗਿਕ ਹੋਇਆਂ घटਕਾਂ—ਕਰਨਲ, ਡੇਟਾਬੇਸ ਇੰਜਣ, ਗੇਮ ਇੰਜਣ—ਲਈ ਜ਼ਰੂਰੀ ਹੈ ਜਿੱਥੇ ਛੋਟੀ-ਛੋਟੀ ਓਵਰਹੈੱਡ ਵੀ ਭਾਰੀ ਲੋਡ ਹੇਠਾਂ ਬੜੇ ਪ੍ਰਭਾਵ ਪਾ ਸਕਦੇ ਹਨ।

ਕੋਰ ਇਨਫਰਾਸਟਰੱਕਚਰ ਲਈ ਪੇਸ਼ਗੋਈ ਯੋਗ ਪ੍ਰਦਰਸ਼ਨ

ਸਿਸਟਮ ਸਾਫਟਵੇਅਰ ਨੂੰ ਅਕਸਰ ਇੱਕਸਾਰ ਸਮਾਂ-ਅੰਕ ਚਾਹੀਦਾ ਹੈ, ਸਿਰਫ਼ ਔਸਤ ਤੇਜ਼ੀ ਨਹੀਂ। ਉਦਾਹਰਨ:

• ਆਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦਾ ਸ਼ਡਿਊਲਰ ਲੋਡ ਹੇਠਾਂ ਤੇਜ਼ੀ ਨਾਲ ਜਵਾਬ ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ।
• ਡੇਟਾਬੇਸ ਨੂੰ ਕਈ ਯੂਜ਼ਰਾਂ ਵੱਲੋਂ ਇੱਕੱਠੇ ਕਾਲਾਂ ਦੌਰਾਨ ਲੈਟੈਂਸੀ ਨੂੰ ਸਥਿਰ ਰੱਖਣਾ ਚਾਹੀਦਾ ਹੈ।
• ਗੇਮ ਇੰਜਣ ਨੂੰ ਫਰੇਮ ਬਜਟ ਨੂੰ ਪੂਰਾ ਕਰਨਾ ਹੋਂਦਾ ਹੈ (ਜਿਵੇਂ 60 FPS ਲਈ ~16 ms)।

C/C++ CPU ਵਰਤੋਂ, ਮੇਮੋਰੀ ਲੇਆਉਟ ਅਤੇ ਡੇਟਾ ਸਟ੍ਰਕਚਰਾਂ 'ਤੇ ਨਿਆੰਤਰਣ ਦਿੰਦੇ ਹਨ, ਜੋ ਇੰਜੀਨੀਅਰਾਂ ਨੂੰ ਪੇਸ਼ਗੋਈਯੋਗ ਪ੍ਰਦਰਸ਼ਨ ਹਾਸਲ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ।

ਸਿੱਧਾ ਮੇਮੋਰੀ ਅਤੇ ਪੋਇੰਟਰ ਐਕਸੇਸ

ਪੋਇੰਟਰ ਤੁਹਾਨੂੰ ਮੇਮੋਰੀ ਐਡਰੈੱਸ ਨਾਲ ਸਿੱਧਾ ਕੰਮ ਕਰਨ ਦਿੰਦੇ ਹਨ। ਇਹ ਸ਼ਕਤੀ ਡਰਾਉਣੀ ਲੱਗ ਸਕਦੀ ਹੈ, ਪਰ ਇਹ ਉਹਨਾਂ ਯੋਗਤਾਵਾਂ ਨੂੰ ਖੋਲ੍ਹਦੀ ਹੈ ਜੋ ਬਹੁਤ-ਸਾਰੇ ਉੱਚ-ਸਤਹ ਭਾਸ਼ਾਵਾਂ ਲੁਕਾ ਦेंदੀਆਂ ਹਨ:

• ਖਾਸ ਵਰਕਲੋਡ ਲਈ ਸੰਗ੍ਰਹਿਤ ਅਲੋਕੇਟਰ
• ਸੰਕੁਚਿਤ ਇਨ-ਮੇਮੋਰੀ ਫਾਰਮੈਟ (ਡੇਟਾਬੇਸ ਅਤੇ ਕੈਸ਼ਾਂ ਲਈ ਲਾਭਦਾਇਕ)
• ਜ਼ੀਰੋ-ਕਾਪੀ I/O ਜੋ ਡੇਟਾ ਨੂੰ ਵਾਰ-ਵਾਰ ਨਕਲ ਨਹੀਂ ਕਰਦਾ

ਧਿਆਨ ਨਾਲ ਵਰਤੋਂ ਕਰਨ 'ਤੇ ਇਹ ਕੰਟਰੋਲ ਨਾਟਕੀਅਤ ਤੇਜ਼ੀ ਵਧਾ ਸਕਦਾ ਹੈ।

ਟਰੇਡ-ਆਫ਼: ਸੁਰੱਖਿਆ, ਜਟਿਲਤਾ ਅਤੇ ਵਿਕਾਸ ਸਮਾਂ

ਇਹੀ ਆਜ਼ਾਦੀ ਵੀ ਖਤਰਾ ਹੈ। ਆਮ ਟਰੇਡ-ਆਫ਼ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨ:

• ਸੁਰੱਖਿਆ: ਗਲਤੀਆਂ ਕੁੜਮ, ਡੇਟਾ ਕਰਪਸ਼ਨ ਜਾਂ ਸੁਰੱਖਿਆ ਖਾਮੀਆਂ ਪੈਦਾ ਕਰ ਸਕਦੀਆਂ ਹਨ।
• ਜਟਿਲਤਾ: ਮੈਨੁਅਲ ਮੇਮੋਰੀ ਪ੍ਰਬੰਧਨ ਅਤੇ ਅਣਿਧਾਰਿਤ ਵਰਤਾਰਾ (undefined behavior) ਤੀਬਰ ਅਨੁਸਾਰਤਾ ਲੈਂਦੇ ਹਨ।
• ਵਿਕਾਸ ਸਮਾਂ: ਭਰੋਸੇਯੋਗਤਾ ਲਈ ਟੈਸਟਿੰਗ, ਰੀਵਿਊ ਅਤੇ ਟੂਲਿੰਗ ਲਾਜ਼ਮੀ ਹੋ ਜਾਂਦਾ ਹੈ।

ਆਮ ਰਵਾਇਤ ਇਹ ਹੈ ਕਿ ਪ੍ਰਦਰਸ਼ਨ-ਨਾਜ਼ੁਕ ਕੋਰ C/C++ ਵਿੱਚ ਰੱਖੋ, ਅਤੇ ਉਤਪਾਦ ਫੀਚਰ ਤੇ UX ਲਈ ਸੁਰੱਖਿਅਤ ਭਾਸ਼ਾਵਾਂ ਨਾਲ ਘੇਰੋ।

C/C++ ਆਪਰੇਟਿੰਗ ਸਿਸਟਮ ਕਰਨਲ ਵਿੱਚ

ਆਪਰੇਟਿੰਗ ਸਿਸਟਮ ਕਰਨਲ ਹਾਰਡਵੇਅਰ ਦੇ ਸਭ ਤੋਂ ਨੇੜੇ ਬੈਠਦਾ ਹੈ। ਜਦੋਂ ਤੁਹਾਡਾ ਲੈਪਟਾਪ ਜਾਗਦਾ ਹੈ, ਬ੍ਰਾਉਜ਼ਰ ਖੁਲਦਾ ਹੈ, ਜਾਂ ਕੋਈ ਪ੍ਰੋਗਰਾਮ ਹੋਰ RAM ਮੰਗਦਾ ਹੈ, ਕਰਨਲ ਉਹ ਸਭ ਸਮਨਵਯ ਕਰ ਰਿਹਾ ਹੁੰਦਾ ਹੈ।

ਕਾਰਜ ਜੋ ਕਰਨਲ ਅਸਲ ਵਿੱਚ ਕਰਦਾ ਹੈ

ਕਾਰਗਿਰੀਕ ਰੂਪ ਵਿੱਚ, ਕਰਨਲ ਕੁਝ ਮੂਲ ਕੰਮ ਸੰਭਾਲਦਾ ਹੈ:

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

ਇਹ ਜਿੰਮੇਵਾਰੀਆਂ ਸਿਸਟਮ ਦੇ ਕੇਂਦਰ ਤੇ ਬੈਠਦੀਆਂ ਹਨ, ਇਸ ਲਈ ਕਰਨਲ ਕੋਡ ਪ੍ਰਦਰਸ਼ਨ-ਸੰਵੇਦਨਸ਼ੀਲ ਅਤੇ ਸਹੀਤਾ-ਸੰਵੇਦਨਸ਼ੀਲ ਦੋਹਾਂ ਹੁੰਦਾ ਹੈ।

ਕਿਉਂ ਸਖਤ ਕੰਟਰੋਲ C (ਅਤੇ ਕਭੀ-ਕਭੀ C++) ਨੂੰ ਤਰਜੀਹ ਦਿੰਦਾ ਹੈ

ਕਰਨਲ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਸਟੀਕ ਕੰਟਰੋਲ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ:

• ਮੇਮੋਰੀ ਲੇਆਉਟ: ਨਿਰਧਾਰਿਤ ਆਕਾਰ ਵਾਲੀ ਸੰਰਚਨਾਵਾਂ, ਅਲਾਈਨਮੈਂਟ ਅਤੇ ਪੇਸ਼ਗੋਈਯੋਗ ਅਲੋਕੇਸ਼ਨ ਵਿਵਹਾਰ।
• CPU ਨਿਰਦੇਸ਼ ਅਤੇ ਕਾਲਿੰਗ ਕਨਵੈਨਸ਼ਨ: ਇੰਟਰਪਟ, ਕੰਟੈਕਸਟ-ਸਵਿੱਚ ਅਤੇ ਨੀਵੀਂ ਸਿੰਕਰੋਨਾਈਜੇਸ਼ਨ ਨਾਲ ਇੰਟਰਐਕਟ ਕਰਨਾ।
• ਹਾਰਡਵੇਅਰ ਰਜਿਸਟਰ: ਖਾਸ ਐਡਰੈੱਸ ਪੜਨਾ/ਲਿਖਣਾ ਅਤੇ ਵਿਸ਼ੇਸ਼ CPU ਮੋਡਾਂ ਨੂੰ ਹੈਂਡਲ ਕਰਨਾ।

C ਇੱਕ ਆਮ “ਕਰਨਲ ਭਾਸ਼ਾ” ਰਹੀ ਹੈ ਕਿਉਂਕਿ ਇਹ ਮਸ਼ੀਨ-ਸਤਹ ਆਮ ਧਾਰਨਾ ਨਾਲ ਸਾਫ਼-ਸੁਥਰੇ ਤਰੀਕੇ ਨਾਲ ਮੇਲ ਖਾਂਦੀ ਹੈ ਅਤੇ ਆਰਕੀਟੈਕਚਰਾਂ ਦੇ ਵਿਚਕਾਰ ਪੋਰਟੇਬਲ ਵੀ ਰਹਿੰਦੀ ਹੈ। ਬਹੁਤ ਸਾਰੇ ਕਰਨਲ ਸਭ ਤੋਂ ਛੋਟੇ-ਤੇ-ਛੋਟੇ ਹਾਰਡਵੇਅਰ-ਨਿਰਧਾਰਿਤ ਹਿੱਸਿਆਂ ਲਈ assembly 'ਤੇ ਭਰੋਸਾ ਕਰਦੇ ਹਨ, ਜਦਕਿ C ਵੱਡਾ ਕੰਮ ਸੰਭਾਲਦਾ ਹੈ।

C++ ਕਰਨਲਾਂ ਵਿੱਚ ਹੋ ਸਕਦਾ ਹੈ ਪਰ ਆਮ ਤੌਰ 'ਤੇ ਸੀਮਿਤ ਅੰਦਾਜ਼ ਵਿੱਚ (ਰੰਟਾਈਮ ਫੀਚਰ ਘੱਟ, ਐਕਸੈਪਸ਼ਨ ਨੀਤੀਆਂ ਧਿਆਨ ਨਾਲ, ਅਤੇ ਅਲੋਕੇਸ਼ਨ ਬਾਰੇ ਕਾਫੀ ਨਿਯਮ)। ਜਿੱਥੇ ਇਸਦਾ ਵਰਤੋਂ ਹੁੰਦਾ ਹੈ, ਉਹ ਆੰਤਰਨਿਕਤਾ (abstraction) ਨੂੰ ਬਹਿਤਰ ਕਰਨ ਲਈ ਹੁੰਦਾ ਹੈ ਬਿਨਾਂ ਕੰਟਰੋਲ ਛੱਡੇ।

ਕਰਨਲ-ਨਜ਼ਦੀਕੀ ਕੋਡ ਜੋ ਅਕਸਰ C/C++ ਵਿੱਚ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ

ਭਾਵੇਂ ਕਰਨਲ ਖੁਦ ਸੰਭਾਲੂ ਹੋਵੇ, ਕਈ ਨਜ਼ਦੀਕੀ ਕੰਪੋਨੇਟ C/C++ ਵਿੱਚ ਹੁੰਦੇ ਹਨ:

• ਡਿਵਾਈਸ ਡਰਾਈਵਰ (ਖਾਸ ਕਰਕੇ ਪ੍ਰਦਰਸ਼ਨ-ਸੰਵੇਦਨਸ਼ੀਲ)
• ਸਟੈਂਡਰਡ ਲਾਇਬ੍ਰੇਰੀਆਂ ਅਤੇ ਰਨਟਾਈਮ (libc ਦੇ ਹਿੱਸੇ, ਨੀਵੀਂ-ਸਤਹ ਥ੍ਰੈਡਿੰਗ)
• ਬੂਟਲੋਡਰ ਅਤੇ ਸ਼ੁਰੂਆਤੀ ਕੋਡ
• ਸਿਸਟਮ ਸਰਵਿਸਿਜ਼ ਜੋ ਨੇਟਿਵ ਗਤੀਸ਼ੀਲਤਾ ਚਾਹੁੰਦੇ ਹਨ (ਜਿਵੇਂ ਨੈੱਟਵਰਕਿੰਗ ਜਾਂ ਸਟੋਰੇਜ ਹੇਲਪਰ)

ਹੋਰ ਵੇਰਵਾ ਲਈ ਡ੍ਰਾਈਵਰਾਂ ਦੇ ਭੁਮਿਕਾ ਬਾਰੇ ਬਲੌਗ ਲੇਖ "Device Drivers and Hardware Access" ਵੇਖੋ।

ਡਿਵਾਈਸ ਡਰਾਈਵਰ ਅਤੇ ਹਾਰਡਵੇਅਰ ਐਕਸੇਸ

ਡਿਵਾਈਸ ਡਰਾਈਵਰ ਇੱਕ ਆਪਰੇਟਿੰਗ ਸਿਸਟਮ ਅਤੇ ਫਿਜ਼ਿਕਲ ਹਾਰਡਵੇਅਰ—ਜਿਵੇਂ ਨੈੱਟਵਰਕ ਕਾਰਡ, GPUs, SSD ਕੰਟਰੋਲਰ, ਆਡੀਓ ਡਿਵਾਈਸ—ਦੇ ਵਿਚਕਾਰ ਅਨੁਵਾਦ ਕਰਦੇ ਹਨ। ਜਦੋਂ ਤੁਸੀਂ "ਪਲੇ" 'ਤੇ ਕਲਿਕ ਕਰਦੇ ਹੋ, ਇੱਕ ਫਾਇਲ ਕੌਪੀ ਕਰਦੇ ਹੋ, ਜਾਂ Wi‑Fi ਨਾਲ ਜੁੜਦੇ ਹੋ, ਇਕ ਡਰਾਈਵਰ ਪਹਿਲਾ ਕੋਡ ਹੁੰਦਾ ਹੈ ਜੋ ਜਵਾਬ ਦੇਣਾ चाहिए।

ਡਰਾਈਵਰ I/O ਦੇ ਗਰਮ ਰਸਤੇ (hot path) 'ਤੇ ਬੈਠਦੇ ਹਨ, ਇਸ ਲਈ ਉਹ ਬਹੁਤ ਪ੍ਰਦਰਸ਼ਨ-ਸੰਵੇਦਨਸ਼ੀਲ ਹੁੰਦੇ ਹਨ। ਕੁਝ ਹੋਰ ਮਾਇਕ੍ਰੋਸੈਕਿੰਡ ਪ੍ਰਤੀ ਪੈਕੇਟ ਜਾਂ ਡਿਸਕ ਰਿਕਵੇਸਟ ਤੇਜ਼ੀ ਨਾਲ ਭਾਰੀ ਪ੍ਰਭਾਵ ਪਾ ਸਕਦੀ ਹੈ। C ਅਤੇ C++ ਇੱਥੇ ਆਮ ਹਨ ਕਿਉਂਕਿ ਉਹ ਸਿੱਧਾ kernel APIs ਨੂੰ ਕਾਲ ਕਰ ਸਕਦੇ ਹਨ, ਮੇਮੋਰੀ ਲੇਆਉਟ ਤੇ ਬਰੀਕ ਕੰਟਰੋਲ ਰੱਖ ਸਕਦੇ ਹਨ, ਅਤੇ ਘੱਟ ਓਵਰਹੈੱਡ ਨਾਲ ਚੱਲ ਸਕਦੇ ਹਨ।

ਇੰਟਰਪਟ, DMA ਅਤੇ ਨੀਚੇ-ਸਤਹ API ਦਾ ਮਹੱਤਵ

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

ਉੱਚ ਥਰੂਪੁੱਟ ਲਈ, ਡਰਾਈਵਰ DMA (Direct Memory Access) 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ, ਜਿੱਥੇ ਡਿਵਾਈਸ ਸਿਸਟਮ ਮੇਮੋਰੀ ਨੂੰ CPU ਤੋਂ ਬਿਨਾਂ ਪੜ੍ਹ/ਲਿਖ ਸਕਦਾ ਹੈ। DMA ਸੈੱਟਅਪ ਆਮ ਤੌਰ 'ਤੇ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ:

• ਸਹੀ ਫਾਰਮੈਟ ਅਤੇ ਅਲਾਈਨਮੈਂਟ ਵਿੱਚ ਬਫਰ ਤਿਆਰ ਕਰਨਾ
• ਡਿਵਾਈਸ ਨੂੰ ਫਿਜ਼ੀਕਲ ਐਡਰੈੱਸ ਜਾਂ ਮੈਪ ਕੀਤੇ ਡਿਸਕ੍ਰਿਪਟਰ ਦੇਣਾ
• ਡਿਵਾਈਸ ਅਤੇ CPU ਦਰਮਿਆਨ ਮੇਮੋਰੀ ਦੀ ਮਲਕੀਅਤ ਨੂੰ ਸਿੰਕਰੋਨਾਈਜ਼ ਕਰਨਾ

ਇਹ ਕੰਮ ਨੀਵੀਂ-ਸਤਹ ਇੰਟਰਫੇਸ ਦੀ ਮੰਗ ਕਰਦੇ ਹਨ: ਮੈਮੋਰੀ-ਮੈਪਡ ਰਜਿਸਟਰ, ਬਿਟ ਫਲੈਗ, ਅਤੇ ਪੜ੍ਹਨ/ਲਿਖਣ ਦੇ ਠੀਕ ਕ੍ਰਮ। C/C++ ਇਸ ਕਿਸਮ ਦੇ "ਮੈਟਲ ਦੇ ਨੇੜੇ" ਤਰਕੀਬ ਨੂੰ ਪ੍ਰਯੋਗਯੋਗ ਅਤੇ ਕ੍ਰਾਸ-ਕੰਪਾਇਲਰ ਪੋਰਟੇਬਲ ਬਣਾਉਂਦੇ ਹਨ।

ਸਥਿਰਤਾ ਬੇ-ਸਰਕਾਰੀ ਹੈ

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

ਟੀਮਾਂ ਖਤਰੇ ਨੂੰ ਘਟਾਉਣ ਲਈ ਸਖ਼ਤ ਕੋਡਿੰਗ ਮਿਆਰ, ਰੱਖਿਆਮੂਲ ਜਾਂਚਾਂ, ਅਤੇ ਪਰਤ-ਦਰ-ਪਰਤ ਸਮੀਖਿਆ ਵਰਤਦੀਆਂ ਹਨ। ਆਮ ਅਭਿਆਸਾਂ ਵਿੱਚ ਅਣ-ਸੁਰੱਖਿਅਤ ਪੋਇੰਟਰ ਵਰਤੋਂ ਨੂੰ ਸੀਮਿਤ ਕਰਨਾ, ਹਾਰਡਵੇਅਰ/ਫਰਮਵੇਅਰ ਤੋਂ ਆਉਣ ਵਾਲੇ ਇਨਪੁੱਟ ਦੀ ਜਾਂਚ ਕਰਨਾ, ਅਤੇ CI ਵਿੱਚ ਸਟੈਟਿਕ ਵਿਸ਼ਲੇਸ਼ਣ ਸ਼ਾਮਲ ਹਨ।

ਮੇਮੋਰੀ ਪ੍ਰਬੰਧਨ: ਤਾਕਤ ਅਤੇ ਖਤਰੇ

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

"ਮੇਮੋਰੀ ਪ੍ਰਬੰਧਨ" ਦਾ ਅਰਥ

ਅਮਲੀ ਰੂਪ ਵਿੱਚ, ਮੇਮੋਰੀ ਪ੍ਰਬੰਧਨ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨ:

• ਅਲੋਕੇਟ ਕਰਨਾ (ਡੇਟਾ ਸੰਭਾਲਣ ਲਈ ਟੁਕੜਾ ਪ੍ਰਾਪਤ ਕਰਨਾ)
• ਫ੍ਰੀ ਕਰਨਾ (ਜਦੋਂ ਤੁਸੀਂ ਖਤਮ ਕਰ ਲਿਆ ਤਾਂ ਉਸਨੂੰ ਵਾਪਸ ਦੇਣਾ)
• ਫ੍ਰੈਗਮੇਂਟੇਸ਼ਨ ਨੂੰ ਸੰਭਾਲਣਾ (ਛੱਡੀਆਂ ਹੋਈਆਂ ਖਾਲੀਆਂ ਥਾਵਾਂ ਜੋ ਭਵਿੱਖ ਦੀਆਂ ਅਲੋਕੇਸ਼ਨਾਂ ਨੂੰ ਮੰਦ ਕਰ ਸਕਦੀਆਂ ਹਨ)

C ਵਿੱਚ ਇਹ ਅਕਸਰ ਸਪਸ਼ਟ ਹੁੰਦਾ ਹੈ (malloc/free)। C++ ਵਿੱਚ ਇਹ ਸਪਸ਼ਟ (new/delete) ਹੋ ਸਕਦਾ ਹੈ ਜਾਂ ਸੁਰੱਖਿਅਤ ਪੈਟਰਨ ਵਿੱਚ ਲਪੇਟਿਆ ਜਾ ਸਕਦਾ ਹੈ।

ਮੈਨੁਅਲ ਕੰਟਰੋਲ ਕਿਉਂ ਫਾਇਦੇਮੰਦ ਹੋ ਸਕਦਾ ਹੈ

ਪ੍ਰਦਰਸ਼ਨ-ਨਾਜ਼ੁਕ ਹਿੱਸਿਆਂ ਵਿੱਚ, ਮੈਨੁਅਲ ਕੰਟਰੋਲ ਇੱਕ ਫੀਚਰ ਹੋ ਸਕਦਾ ਹੈ:

• ਤੁਸੀਂ ਗਾਰਬੇਜ਼ ਕਲੇਕਸ਼ਨ ਦੀ ਅਣਪੇਸ਼ਗੋਈ ਰੁਕਾਵਟ ਤੋਂ ਬਚ ਸਕਦੇ ਹੋ।
• ਤੁਸੀਂ ਨਿਰਧਾਰਿਤ ਕਰ ਸਕਦੇ ਹੋ ਕਿੱਥੇ ਅਤੇ ਕਿਵੇਂ ਮੇਮੋਰੀ ਅਲੋਕੇਟ ਹੋਵੇ (ਜਿਵੇਂ ਪੂਲਡ ਜਾਂ ਏਰੀਨਾ ਅਲੋਕੇਟਰ), ਜੋ ਸਥਿਰਤਾ ਸੁਧਾਰਦਾ ਹੈ।
• ਤੁਸੀਂ ਅਲੋਕੇਸ਼ਨ ਪੈਟਰਨ ਨੂੰ ਵਾਸਤਵਿਕ ਵਰਕਲੋਡ ਲਈ ਅਨੁਕੂਲ ਕਰ ਸਕਦੇ ਹੋ (ਬਹੁਤ ਸਾਰੇ ਛੋਟੇ ਆਬਜੈਕਟ vs ਵੱਡੇ ਲਗਾਤਾਰ ਬਫਰ)।

ਜਦੋਂ ਡੇਟਾਬੇਸ ਨੂੰ ਲੱਗਾਤਾਰ ਲੈਟੈਂਸੀ ਬਣਾਈ ਰੱਖਣੀ ਹੋਵੇ ਜਾਂ ਗੇਮ ਇੰਜਣ ਨੂੰ ਫਰੇਮ-ਟਾਈਮ ਬਜਟ ਪੂਰਾ ਕਰਨਾ ਹੋਵੇ, ਇਹ ਮਹੱਤਵਪੂਰਨ ਹੁੰਦਾ ਹੈ।

ਆਮ ਫੇਲਯੋਗ ਮੋਡ (ਅਤੇ ਉਹ ਗੰਭੀਰ ਕਿਉਂ ਹਨ)

ਇਸੀ ਆਜ਼ਾਦੀ ਨਾਲ ਕੁਝ ਕਲਾਸਿਕ ਸਮੱਸਿਆਵਾਂ ਹੁੰਦੀਆਂ ਹਨ:

• ਮੇਮੋਰੀ ਲੀਕ: ਭੁੱਲ ਕੇ ਮੇਮੋਰੀ ਨੂੰ ਫ੍ਰੀ ਨਾ ਕਰਨਾ, ਜਿਸ ਨਾਲ ਉਪਯੋਗਤਾ ਵੱਧਦੀ ਜਾਂ ਪ੍ਰੋਸੈਸ ਕਰੈਸ਼ ਹੋ ਜਾਂਦਾ ਹੈ।
• ਬਫਰ ਓਵਰਫਲੋ: ਐਰੇ ਦੀ ਸੀਮਾ ਤੋਂ ਬਾਹਰ ਲਿਖਣਾ, ਡੇਟਾ ਕਰਪਟ ਹੋ ਸਕਦਾ ਹੈ ਜਾਂ ਹੈਕਿੰਗ ਲਈ ਦਰਵਾਜ਼ਾ ਖੁਲ ਸਕਦਾ ਹੈ।
• ਯੂਜ਼-ਆਫਟਰ-ਫ੍ਰੀ: ਫ੍ਰੀ ਕੀਤੀ ਹੋਈ ਹਵਾਲੇ ਦੀ ਵਰਤੋਂ, ਜੋ ਰੀਪ੍ਰੋਡਿਊਸ ਕਰਨ ਵਿੱਚ ਮੁਸ਼ਕਲ ਕਰੈਸ਼ ਲਿਆਉਂਦਾ ਹੈ।

ਇਹ ਬੱਗ ਸੁਖਮ ਹੁੰਦੇ ਹਨ ਕਿਉਂਕਿ ਪ੍ਰੋਗਰਾਮ "ਠੀਕ ਲੱਗ ਸਕਦਾ ਹੈ" ਜਦ ਤੱਕ ਕੋਈ ਖਾਸ ਵਰਕਲੋਡ ਫੇਲ੍ਹਰ ਨੂੰ ਟ੍ਰਿigger ਨਾ ਕਰੇ।

ਆਧੁਨਿਕ ਅਭਿਆਸ ਇਹਨਾਂ ਦੀ ਮਦਦ ਕਰਦੇ ਹਨ

ਆਧੁਨਿਕ C++ ਸੰਭਾਲ ਬਿਨਾਂ ਕੰਟਰੋਲ ਖੋਏ ਖਤਰੇ ਘਟਾਉਂਦਾ ਹੈ:

• RAII (Resource Acquisition Is Initialization) ਰਿਸੋਰਸ ਦੀ ਅਵਧੀ ਨੂੰ ਸਕੋਪ ਨਾਲ ਜੋੜਦਾ ਹੈ ਤਾਂ ਕਿ ਸਾਫ਼-ਸਫਾਈ ਆਟੋਮੈਟਿਕ ਹੋ ਜਾਵੇ।
• ਸਮਾਰਟ ਪੋਇੰਟਰ (ਜਿਵੇਂ std::unique_ptr, std::shared_ptr) ਮਾਲਕੀਅਤ ਨੂੰ ਵਿਅਕਤ ਕਰਦੇ ਹਨ ਅਤੇ ਕਈ ਲੀਕ ਰੋਕਦੇ ਹਨ।
• Sanitizers (AddressSanitizer, UndefinedBehaviorSanitizer) ਅਤੇ ਸਟੈਟਿਕ ਵਿਸ਼ਲੇਸ਼ਣ CI ਵਿੱਚ ਮੁੱਦੇ ਜਲਦੀ ਪਕੜ ਲੈਂਦੇ ਹਨ।

ਇਨ੍ਹਾਂ ਟੂਲਜ਼ ਦੀ ਸਮਝਦਾਰੀ ਨਾਲ ਵਰਤੋਂ C/C++ ਨੂੰ ਤੇਜ਼ ਰੱਖਦੀ ਹੈ ਤੇ ਮੇਮੋਰੀ ਬੱਗ ਪ੍ਰੋਡਕਸ਼ਨ ਤੱਕ ਪਹੁੰਚਣ ਦੀ ਸੰਭਾਵਨਾ ਘਟਾ ਦਿੰਦੀ ਹੈ।

concurrency ਅਤੇ ਮਲਟੀ-ਕੋਰ ਪ੍ਰਦਰਸ਼ਨ

ਆਧੁਨਿਕ CPUs ਹਰ ਕੋਰ 'ਤੇ ਸ਼ਾਹਕਾਰ ਤੇਜ਼ੀ ਨਹੀਂ ਲਾ ਰਹੇ—ਉਹ ਹੋਰ ਕੋਰ ਦੇ ਰਹੇ ਹਨ। ਇਹ ਪ੍ਰਦਰਸ਼ਨ ਸਵਾਲ ਨੂੰ ਬਦਲ ਦਿੰਦਾ ਹੈ: "ਮੇਰਾ ਕੋਡ ਕਿੰਨਾ ਚੰਗੀ ਤਰ੍ਹਾਂ ਪੈਰਲਲ ਚੱਲ ਸਕਦਾ ਹੈ ਬਿਨਾਂ ਇੱਕ-ਦੂਜੇ ਨੂੰ ਰੋਕਣ ਦੇ?" C ਅਤੇ C++ ਇੱਥੇ ਲੋਕਪ੍ਰਿਯ ਹਨ ਕਿਉਂਕਿ ਉਹ ਥ੍ਰੈਡਿੰਗ, ਸਿੰਕਰੋਨਾਈਜ਼ੇਸ਼ਨ ਅਤੇ ਮੇਮੋਰੀ ਵਿਹਾਰ ਉਤੇ ਘੱਟ ਓਵਰਹੈੱਡ ਨਾਲ ਨੀਵੀਂ-ਸਤਹ ਕੰਟਰੋਲ ਦਿੰਦੇ ਹਨ।

ਥ੍ਰੈਡ, ਕੋਰ ਅਤੇ ਸ਼ਡਿਊਲਿੰਗ

ਥ੍ਰੈਡ ਉਹ ਯੂਨਿਟ ਹੈ ਜਿਸ 'ਤੇ ਤੁਹਾਡਾ ਪ੍ਰੋਗਰਾਮ ਕੰਮ ਕਰਾਉਂਦਾ ਹੈ; CPU ਕੋਰ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ ਉਹ ਕੰਮ ਚੱਲਦਾ ਹੈ। OS ਸ਼ਡਿਊਲਰ ਚਲਦੇ ਥ੍ਰੈਡਸ ਨੂੰ ਉਪਲਬਧ ਕੋਰਾਂ 'ਤੇ ਨਕਸ਼ਾ ਬਣਾਉਂਦਾ ਹੈ, ਬਾਰੰਬਾਰ ਫੈਸਲੇ ਕਰਦਾ ਰਹਿੰਦਾ ਹੈ।

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

ਲਾਕਿੰਗ ਬੁਨਿਆਦੀ: ਮਿਊਟੈਕਸ, ਐਟੌਮਿਕਸ, ਅਤੇ ਟੱਕਰ

• ਮਿਊਟੈਕਸ ਸੋਚਣ ਵਿੱਚ ਆਸਾਨ ਹੁੰਦੇ ਹਨ, ਪਰ ਜ਼ਿਆਦਾ ਸਾਂਝਾ ਹੋਣ 'ਤੇ ਕੰਟੈਂਸ਼ਨ ਹੁੰਦੀ ਹੈ—ਉਸ ਸਮੇਂ ਤੇ ਕੰਮ ਕਰਨ ਦੀ ਬਜਾਏ ਇੰਤਜ਼ਾਰ ਹੋਣਾ।
• ਐਟੌਮਿਕਸ ਛੋਟੀ ਸਾਂਝੀ-ਸਟੇਟ ਅੱਪਡੇਟ ਲਈ ਤੇਜ਼ ਹੋ ਸਕਦੇ ਹਨ, ਪਰ ਸੁਖਮ ਸਹੀਤਾ ਬੱਗ ਪੈਦਾ ਕਰ ਸਕਦੇ ਹਨ।

ਵਾਸਤਵਿਕ ਲਕੜੀ ਇਹ ਨਹੀਂ ਕਿ "ਕਦੇ ਲਾਕ ਨਾ ਕਰੋ"। ਮਕਸਦ: ਘੱਟ ਲਾਕ ਕਰੋ, ਤੇਜ਼ੀ ਨਾਲ ਲਾਕ ਕਰੋ—ਕ੍ਰਿਟੀਕਲ ਸੈਕਸ਼ਨਾਂ ਨੂੰ ਛੋਟਾ ਰੱਖੋ, ਗਲੋਬਲ ਲਾਕ ਤੋਂ بچੋ ਅਤੇ ਸਾਂਝੀ ਬਦਲਣਯੋਗ ਸਟੇਟ ਨੂੰ ਘਟਾਓ।

ਕਿਉਂ ਲੈਟੈਂਸੀ ਸਪਾਈਕ ਮਹੱਤਵਪੂਰਨ ਹਨ

ਡੇਟਾਬੇਸ ਅਤੇ ਗੇਮ ਇੰਜਣ ਸਿਰਫ਼ ਔਸਤ ਤੇਜ਼ੀ ਦੀ ਪਰਵਾਹ ਨਹੀਂ ਕਰਦੇ—ਉਹ ਵਰਲਾਸਟ-ਕੇਸ ਰੁਕਾਵਟਾਂ ਦੀ ਵੀ ਪਰਵਾਹ ਕਰਦੇ ਹਨ। ਇਕ ਲਾਕ ਕਨਵਓ, ਪੇਜ ਫੌਲਟ, ਜਾਂ ਰੁਕੇ ਹੋਏ ਵਰਕਰ ਕਾਰਨ ਦਿਖਾਈ ਦੇਣ ਵਾਲੀ ਸਟਟਰ ਜਾਂ SLA ਭੰਗ ਹੋ ਸਕਦਾ ਹੈ।

ਆਮ C/C++ ਪੈਟਰਨ

ਕਈ ਉੱਚ-ਪ੍ਰਦਰਸ਼ਨ ਸਿਸਟਮ ਇਨ੍ਹਾਂ 'ਤੇ ਨਿਰਭਰ ਹੁੰਦੇ ਹਨ:

• ਥ੍ਰੈਡ ਪੁਲ ਜੋ ਵਰਕਰਾਂ ਨੂੰ ਦੁਬਾਰਾ ਵਰਤਦੇ ਹਨ ਅਤੇ ਸ਼ਡਿਊਲਿੰਗ ਨੂੰ ਪੇਸ਼ਗੀਯੋਗ ਬਣਾਉਂਦੇ ਹਨ।
• ਵਰਕ-ਸਟਿਲਿੰਗ ਕਿਊਜ਼ ਜੋ ਕੋਰਾਂ 'ਤੇ ਲੋਡ ਨੂੰ ਸੰਤੁਲਿਤ ਕਰਦੇ ਹਨ।
• ਲਾਕ-ਮੁਕਤ ਕਿਊਜ਼ (ਚੁਣਿੰਦਾ ਹਾਟ ਪਾਥਸ 'ਚ) ਬਲਾਕਿੰਗ ਘਟਾਉਣ ਲਈ—ਇਸਨੂੰ ਸਾਵਧਾਨੀ ਨਾਲ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਕਿਉਂਕਿ ਸਹੀਤਾ ਸਾਬਤ ਕਰਨਾ ਮੁਸ਼ਕਲ ਹੈ।

ਇਹ ਪੈਟਰਨ ਸਮਰੱਥਾ ਅਤੇ ਲੈਟੈਂਸੀ ਦੋਹਾਂ 'ਤੇ ਧਿਆਨ ਰੱਖਦੇ ਹਨ।

ਡੇਟਾਬੇਸ ਇੰਜਣ: ਜਿੱਥੇ C/C++ ਤੇਜ਼ੀ ਦਿਖਾਉਂਦੇ ਹਨ

ਡੇਟਾਬੇਸ ਇੰਜਣ ਸਿਰਫ਼ "ਰੋਜ਼ਾਂ ਸਟੋਰ" ਨਹੀਂ ਹੁੰਦਾ। ਇਹ CPU ਅਤੇ I/O ਦੇ ਤੇਜ਼ ਲੂਪ ਦਾ ਕੰਮ ਹੈ ਜੋ ਸੈਕੰਡ ਵਿੱਚ ਲੱਖਾਂ ਵਾਰੀ ਚੱਲਦਾ ਹੈ, ਜਿੱਥੇ ਛੋਟੀ-ਛੋਟੀ ਅਣਗੌਲਾਈਆਂ ਤੇਜ਼ੀ ਨਾਲ ਗੁਣਾ ਹੋ ਜਾਂਦੀਆਂ ਹਨ। ਇਸ ਲਈ ਬਹੁਤ ਸਾਰੇ ਇੰਜਣ ਅਤੇ ਕੋਰ ਕੰਪੋਨੇਟ ਅਜੇ ਵੀ ਵੱਡੇ ਪੱਧਰ 'ਤੇ C ਜਾਂ C++ ਵਿੱਚ ਲਿਖੇ ਜਾਂਦੇ ਹਨ।

ਇੰਜਣ ਦਾ ਮੁੱਖ ਕੰਮ: ਪਾਰਸ, ਪਲੈਨ, ਐਕਜ਼ਿਕਿਊਟ

ਜਦੋਂ ਤੁਸੀਂ SQL ਭੇਜਦੇ ਹੋ, ਇੰਜਣ:

1. ਪਾਰਸ ਕਰਦਾ ਹੈ (ਟੈਕਸਟ ਨੂੰ ਸੰਰਚਿਤ ਰੇਪ੍ਰੇਜ਼ੇਂਟੇਸ਼ਨ ਵਿੱਚ ਬਦਲਦਾ ਹੈ)
2. ਪਲੈਨ ਕਰਦਾ ਹੈ (ਇੱਕ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਤਰੀਕਾ ਚੁਣਦਾ ਹੈ)
3. ਐਕਜ਼ਿਕਿਊਟ ਕਰਦਾ ਹੈ (ਸਕੈਨ, ਇੰਡੈਕਸ ਲੁੱਕਅਪ, ਜੋਇਨ, ਸੋਰਟ, ਐਗਰੀਗੇਟ ਅਤੇ ਰੋਜ਼ ਵਾਪਸ ਕਰਦਾ ਹੈ)

ਹਰ ਮੰਚੇ ਨੂੰ ਮੇਮੋਰੀ ਅਤੇ CPU ਸਮਾਂ 'ਤੇ ਧਿਆਨ ਨਾਲ ਕੰਟਰੋਲ ਕਰਨ ਨਾਲ ਫਾਇਦਾ ਹੁੰਦਾ ਹੈ। C/C++ ਤੇਜ਼ ਪਾਰਸਰ, ਪਲੈਨ ਦੌਰਾਨ ਘੱਟ ਅਲੋਕੇਸ਼ਨ, ਅਤੇ ਲੀਨ ਐਕਜ਼ਿਕਿਊਸ਼ਨ ਹਾਟ-ਪਾਥ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹਨ—ਅਕਸਰ ਵਰਕਲੋਡ ਲਈ ਖਾਸ ਡੇਟਾ ਸਟ੍ਰਕਚਰਾਂ ਨਾਲ।

ਸਟੋਰੇਜ ਇੰਜਣ: ਪੰਨਿਆਂ (pages), ਇੰਡੈਕਸ, ਬਫਰਿੰਗ

SQL ਲੇਅਰ ਦੇ ਹੇਠਾਂ, ਸਟੋਰੇਜ ਇੰਜਣ ਉਹਨਾਂ ਨਿਰੰਤਰ ਪਰਣਾਲੀਆਂ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ:

• ਪੇਜ: ਡੇਟਾ ਨੂੰ ਨਿਰਧਾਰਿਤ ਅਕਾਰ ਦੇ ਬਲਾਕਾਂ ਵਿੱਚ ਪੜ੍ਹਿਆ ਅਤੇ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ, ਨਾ ਕਿ ਰੋਜ਼-ਦਰ-ਰੋਜ਼।
• ਇੰਡੈਕਸ: B-ਟ੍ਰੀ, LSM-ਟ੍ਰੀ ਅਤੇ ਸਬੰਧਤ ਸੰਰਚਨਾਵਾਂ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਤਰੀਕੇ ਨਾਲ ਅਪਡੇਟ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।
• ਬਫਰਿੰਗ: ਇੱਕ ਬਫਰ ਪੂਲ ਫੈਸਲਾ ਕਰਦਾ ਹੈ ਕਿ ਕੀ RAM ਵਿੱਚ ਰਹੇ, ਕੀ ਨਿਕਾਲਿਆ ਜਾਵੇ, ਅਤੇ ਪੜ੍ਹਨ/ਲਿਖਨ ਕਿਵੇਂ ਬੈਚ ਕੀਤਾ ਜਾਵੇ।

ਇਹਨਾਂ ਕੰਪੋਨੇਟਾਂ ਲਈ C/C++ ਮਜ਼ਬੂਤ ਫ਼ਿੱਟ ਹਨ ਕਿਉਂਕਿ ਇਹ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਮੇਮੋਰੀ ਲੇਆਉਟ ਅਤੇ I/O ਸਥਰੀਆਂ ਉੱਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ।

ਕੈਸ਼-ਮਿੱਤਰ ਡੇਟਾ ਸਟ੍ਰਕਚਰ (ਕਿਉਂ ਮਹੱਤਵਪੂਰਨ)

ਆਧੁਨਿਕ ਪ੍ਰਦਰਸ਼ਨ ਅਕਸਰ ਕੱਚੇ CPU ਗਤੀ ਤੋਂ ਵੱਧ CPU ਕੈਸ਼ 'ਤੇ ਨਿਰਭਰ ਹੁੰਦਾ ਹੈ। C/C++ ਨਾਲ डਿਵੈਲਪਰ ਅਕਸਰ ਵਾਰ-ਵਾਰ ਵਰਤੀਆਂ ਫੀਲਡਾਂ ਨੂੰ ਇਕੱਠੇ ਰੱਖ ਸਕਦੇ ਹਨ, ਕਾਲਮਾਂ ਨੂੰ ਲਗਾਤਾਰ ਐਰੇਜ਼ ਵਿੱਚ ਸਟੋਰ ਕਰ ਸਕਦੇ ਹਨ, ਅਤੇ ਪੁਆਇੰਟਰ ਚੇਜ਼ਿੰਗ ਘਟਾ ਸਕਦੇ ਹਨ—ਇਹ ਉਹ ਪੈਟਰਨ ਹਨ ਜੋ ਡੇਟਾ ਨੂੰ CPU ਨੇੜੇ ਰੱਖਕੇ ਰੁਕਾਵਟਾਂ ਘਟਾਉਂਦੇ ਹਨ।

ਉੱਚ-ਸਤਹ ਭਾਸ਼ਾਵਾਂ ਕਿੱਥੇ ਦਿਖਾਈ ਦਿੰਦੇ ਹਨ

C/C++-ਭਾਰੀ ਡੇਟਾਬੇਸਾਂ ਵਿੱਚ ਵੀ, ਉੱਚ-ਸਤਹ ਭਾਸ਼ਾਵਾਂ ਆਮ ਤੌਰ 'ਤੇ ਐਡਮਿਨ ਟੂਲ, ਬੈਕਅੱਪ, ਮਾਨੀਟਰੀੰਗ, ਮਾਈਗ੍ਰੇਸ਼ਨ, ਅਤੇ ਆਰਕੀਸਟ੍ਰੇਸ਼ਨ ਲਈ ਵਰਤੀ ਜਾਂਦੀਆਂ ਹਨ। ਪ੍ਰਦਰਸ਼ਨ-ਨਾਜ਼ੁਕ ਕੋਰ ਨੇਟਿਵ ਰਹਿੰਦਾ ਹੈ; ਆਸ پاس ਦਾ ਪਰਿਵੇਸ਼ ਤੇਜ਼ ਇਟਰੈਸ਼ਨ ਅਤੇ ਵਰਤੋਂਕਾਰੀ ਸੁਵਿਧਾ ਨੂੰ ਤਰਜੀਹ ਦਿੰਦਾ ਹੈ।

ਡੇਟਾ ਸਟੋਰੇਜ, ਕੈਸ਼ਿੰਗ, ਅਤੇ I/O

ਡੇਟਾਬੇਸ ਤੁਰੰਤ ਮਹਿਸੂਸ ਹੁੰਦੇ ਹਨ ਕਿਉਂਕਿ ਉਹ ਡਿਸਕ ਤੋਂ ਬਚਣ ਲਈ ਭਾਰੀ ਮਿਹਨਤ ਕਰਦੇ ਹਨ। ਤੇਜ਼ SSD ਹੋਣ ਦੇ ਬਾਵਜੂਦ, ਸਟੋਰੇਜ਼ ਰੀਡਿੰਗ RAM ਨਾਲੋਂ ਕਈ ਗੁਣਾ ਧੀਮੀ ਹੁੰਦੀ ਹੈ। ਇਕ C ਜਾਂ C++ ਵਿੱਚ ਲਿਖਿਆ ਡੇਟਾਬੇਸ इंजਣ ਹਰ ਵੇਲੇ ਉਸ ਪ੍ਰਤੀਖਿਆ ਨੂੰ ਕੰਟਰੋਲ ਕਰ ਸਕਦਾ ਹੈ—ਅਤੇ ਅਕਸਰ ਉਸਨੂੰ ਛੁਪਾ ਵੀ ਸਕਦਾ ਹੈ।

ਬਫਰ ਪੂਲ ਅਤੇ ਪੇਜ ਕੈਸ਼ ਸਧਾਰਨ ਸ਼ਬਦਾਂ 'ਚ

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

• ਬਫਰ ਪੂਲ: ਡੇਟਾਬੇਸ ਦਾ ਆਪਣਾ "ਮੀਜ਼" ਜੋ ਹਾਲੀ-ਹਾਲੀ ਵਰਤੇ ਗਏ ਪੇਜ (ਟੇਬਲ ਅਤੇ ਇੰਡੈਕਸ ਦੇ ਨਿਰਧਾਰਿਤ ਟੁਕੜੇ) ਰੱਖਦਾ ਹੈ।
• ਪੇਜ ਕੈਸ਼: ਓਐਸ ਦੀ "ਮੀਜ਼" ਜੋ ਹਾਲੀ-ਹਾਲੀ ਪੜ੍ਹੇ ਫਾਈਲ ਡੇਟਾ ਨੂੰ cached ਰੱਖਦੀ ਹੈ।

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

ਡਿਸਕ ਧੀਮ੍ਹਾ ਕਿਉਂ ਹੈ—ਅਤੇ ਕੈਸ਼ਿੰਗ ਇਸਨੂੰ ਕਿਵੇਂ ਛੁਪਾਉਂਦੀ ਹੈ

ਸਟੋਰੇਜ਼ ਸਿਰਫ਼ ਧੀਮ੍ਹਾ ਨਹੀਂ; ਇਹ ਅਣਪੇਸ਼ਗੋਈ ਵੀ ਹੁੰਦਾ ਹੈ। ਲੈਟੈਂਸੀ ਸਪਾਈਕ, ਕਤਕਾਰ, ਅਤੇ ਰੈੰਡਮ ਐਕਸੇਸ ਸਾਰੇ ਦੇਰ ਵਧਾਉਂਦੇ ਹਨ। ਕੈਸ਼ਿੰਗ ਇਹਨਾਂ ਨੂੰ ਕਿਵੇਂ ਘਟਾਉਂਦੀ ਹੈ:

• ਪੜ੍ਹਾਈਆਂ ਨੂੰ ਆਮ ਤੌਰ 'ਤੇ RAM ਤੋਂ ਸਰਵ ਕਰਨਾ
• ਲਿਖਤਾਂ ਨੂੰ ਘੱਟ, ਵੱਡੇ I/O ਆਪਰੇਸ਼ਨ ਵਿੱਚ ਬੈਚ ਕਰਨਾ
• ਅਗਲੇ ਮੈੰਗੇ ਜਾਣ ਵਾਲੇ ਪੇਜਾਂ ਨੂੰ ਪੇਸ਼ਗੀ ਲੈ ਆਉਣਾ (ਜਿਵੇਂ ਇੰਡੈਕਸ ਸਕੈਨਾਂ ਦੌਰਾਨ)

ਨੀਚੇ-ਸਤਹ ਕੰਟਰੋਲ ਤੋਂ ਫਾਇਦਾ ਉਠਾਉਣ ਵਾਲੇ ਡਿਜ਼ਾਇਨ ਚੋਣਾਂ

C/C++ ਡੇਟਾਬੇਸ ਇੰਜਣਾਂ ਨੂੰ ਉਹ ਵੇਰਵੇ ਸੁਧਾਰਨ ਦੀ ਆਜ਼ਾਦੀ ਦਿੰਦੇ ਹਨ ਜੋ ਉੱਚ ਥਰੂਪੁੱਟ 'ਤੇ ਮਾਇਨੇ ਰੱਖਦੇ ਹਨ: ਅਲਾਈਨਡ ਰੀਡ, ਡਾਇਰੈਕਟ I/O ਵਿਰੁੱਧ ਬਫਰਡ I/O, ਕਸਟਮ ਐਵੀਕਸ਼ਨ ਨੀਤੀਆਂ, ਅਤੇ ਇੰਡੈਕਸਾਂ ਅਤੇ ਲੌਗ ਬਫਰਾਂ ਲਈ ਧਿਆਨ ਨਾਲ ਬਣੇ ਇਨ-ਮੇਮੋਰੀ ਲੇਆਉਟ। ਇਹ ਚੋਣਾਂ ਨਕਲਾਂ ਨੂੰ ਘਟਾਉਂਦੀਆਂ ਹਨ, ਟਕਰਾਅ ਤੋਂ ਬਚਾਉਂਦੀਆਂ ਹਨ, ਅਤੇ CPU ਕੈਸ਼ ਨੂੰ ਪ੍ਰਯੋਗਯੋਗ ਡੇਟਾ ਨਾਲ ਭਰਕੇ ਰੱਖਦੀਆਂ ਹਨ।

ਕੰਪ੍ਰੈਸ਼ਨ ਅਤੇ ਚੈਕਸਮਜ਼ CPU-ਬਾਊਂਡ ਹੋ ਸਕਦੇ ਹਨ

ਕੈਸ਼ਿੰਗ I/O ਘਟਾਉਂਦੀ ਹੈ, ਪਰ CPU ਕੰਮ ਵਧਾਉਂਦੀ ਹੈ। ਪੇਜਾਂ ਨੂੰ ਡਿਕੰਪ੍ਰੈਸ ਕਰਨਾ, ਚੈਕਸਮ ਹਿਸਾਬ ਕਰਨਾ, ਲਾਗ ਨੂੰ ਇਨਕ੍ਰਿਪਟ/ਵੈਰਿਫਾਈ ਕਰਨਾ CPU ਬੋਤਲਨੈਕ ਬਣ ਸਕਦੇ ਹਨ। ਕਿਉਂਕਿ C ਅਤੇ C++ ਮੇਮੋਰੀ ਐਕਸੇਸ ਪੈਟਰਨ ਅਤੇ SIMD-ਅਨੁਕੂਲ ਲੂਪਾਂ 'ਤੇ ਕੰਟਰੋਲ ਦਿੰਦੇ ਹਨ, ਉਂਝ ਉਹ ਅਕਸਰ ਹਰ ਕੋਰ ਤੋਂ ਵੱਧ ਕੰਮ ਖਿੱਚਣ ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਹਨ।

ਗੇਮ ਇੰਜਣ: ਰੀਅਲ-ਟਾਈਮ ਮਿਆਰ

ਗੇਮ ਇੰਜਣ ਸਖ਼ਤ ਰੀਅਲ-ਟਾਈਮ ਉਮੀਦਾਂ 'ਤੇ ਕੰਮ ਕਰਦੇ ਹਨ: ਖਿਡਾਰੀ ਕੈਮਰਾ ਘੁਮਾਉਂਦਾ ਹੈ, ਬਟਨ ਦਬਾਉਂਦਾ ਹੈ, ਅਤੇ ਦੁਨੀਆ ਨੂੰ ਤੁਰੰਤ ਜਵਾਬ ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਹ ਮਾਪ ਫਰੇਮ ਟਾਈਮ ਵਿੱਚ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਨਾ ਕਿ ਔਸਤ ਥਰੂਪੁੱਟ ਵਿੱਚ।

ਫਰੇਮ ਬਜਟ: ਕਿਉਂ ਮਿਲੀਸੈਕਿੰਡ ਲੱਭਦੇ ਹਨ

60 FPS ਤੇ, ਤੁਹਾਨੂੰ ਇੱਕ ਫਰੇਮ ਬਣਾਉਣ ਲਈ ਲਗਭਗ 16.7 ms ਮਿਲਦੇ ਹਨ: ਸਿਮੂਲੇਸ਼ਨ, ਐਨੀਮੇਸ਼ਨ, ਫਿਜ਼ਿਕਸ, ਆਡੀਓ ਮਿਕਿੰਗ, ਕਲਿੰਗ (culling), ਰੇੰਡਰ ਸਬਮਸ਼ਨ, ਅਤੇ ਅਕਸਰ ਐਸੈਟ ਸਟ੍ਰੀਮਿੰਗ। 120 FPS ਤੇ ਇਹ ਬਜਟ ਘਟ ਕੇ 8.3 ms ਹੋ ਜਾਂਦਾ ਹੈ। ਬਜਟ ਮਿਸ ਹੋਣ 'ਤੇ ਖਿਡਾਰੀ ਨੂੰ ਸਟਟਰ, ਇਨਪੁੱਟ ਲੈਗ ਜਾਂ ਅਸਥਿਰ ਪੇਸਿੰਗ ਮਹਿਸੂਸ ਹੁੰਦੀ ਹੈ।

ਇਸੀ ਲਈ C programming ਅਤੇ C++ programming ਇੰਜਣ ਕੋਰ ਵਿੱਚ ਆਮ ਹਨ: ਪੇਸ਼ਗੋਈਯੋਗ ਪ੍ਰਦਰਸ਼ਨ, ਘੱਟ ਓਵਰਹੈੱਡ, ਅਤੇ ਮੇਮੋਰੀ/CPU ਵਰਤੋਂ ਉਤੇ ਨਜ਼ਾਕਤ ਭਰਾ ਕੰਟਰੋਲ।

ਮੂਲ ਸਬਸਿਸਟਮ ਅਕਸਰ C/C++ ਵਿੱਚ

ਜ਼ਿਆਦਾਤਰ ਇੰਜਣ ਭਾਰੀ ਕੰਮ ਲਈ ਨੇਟਿਵ ਕੋਡ ਵਰਤਦੇ ਹਨ:

• ਰੇੰਡਰਿੰਗ (ਸੀਨ ਟਰੈਵਰਸਲ, ਡਰੌ-ਕਾਲ ਬਣਾਉਣਾ, GPU ਰਿਸੋর্স ਮੈਨੇਜਮੈਂਟ)
• ਫਿਜ਼ਿਕਸ (ਕਾਲੀਜਨ ਡਿਟੈਕਸ਼ਨ, ਕੰਸਟਰੇਨਟ, ਰਿੱਡੀਡ ਬਾਡੀਜ਼)
• ਐਨੀਮੇਸ਼ਨ (ਸਕੀਲਟਲ ਬਲੈਂਡਿੰਗ, IK, ਪੋਜ਼ ਇवैਲੁਏਸ਼ਨ)
• ਆਡੀਓ (ਰੀਅਲ-ਟਾਈਮ ਮਿਕਿੰਗ, ਸਪੇਸ਼ਲਾਈਜ਼ੇਸ਼ਨ)

ਇਹ ਸਿਸਟਮ ਹਰ ਫਰੇਮ ਚੱਲਦੇ ਹਨ, ਇਸ ਲਈ ਛੋਟੀ ਆਗਿਆਵਲੀ ਗਲਤੀ ਵੀ ਤੇਜ਼ੀ ਨਾਲ ਵੱਡੀ ਹੋ ਜਾਂਦੀ ਹੈ।

ਕਸੇ ਹੋਏ ਲੂਪ ਅਤੇ ਡੇਟਾ ਲੇਆਉਟ

ਕਈ ਖੇਡ ਦੀ ਪ੍ਰਦਰਸ਼ਨ ਤੰਗ ਲੂਪਾਂ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ: ਐਂਟੀਟੀਜ਼ ਨੂੰ ਇਟਰੇਟ ਕਰਨਾ, ਟਰਾਂਸਫਾਰਮ ਅਪਡੇਟ ਕਰਨਾ, ਕੋਲਿਜ਼ਨ ਟੈਸਟ, ਵੈਨਸਿੰਗ vertices। C/C++ ਇਸਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਮੌਕਾ ਦਿੰਦੇ ਹਨ ਕਿ ਯਾਦਦਾਸ਼ਤ ਕੈਸ਼ ਲਈ ਮੇਮੋਰੀ ਸਟ੍ਰਕਚਰ ਬਣਾਈ ਜਾਵੇ (ਲਗਾਤਾਰ ਐਰੇਜ਼, ਘੱਟ ਅਲੋਕੇਸ਼ਨ, ਘੱਟ ਵਰਚੁਅਲ ਇੰਡਾਇਰੈਕਸ਼ਨ)। ਡੇਟਾ ਲੇਆਉਟ ਅਕਸਰ ਅਲਗੋ੍ਰਿਦਮ ਚੋਣ ਦੇ ਜਿੰਨਾ ਹੀ ਮਹੱਤਵਪੂਰਨ ਹੁੰਦਾ ਹੈ।

ਸਕ੍ਰਿਪਟਿੰਗ ਦਾ ਸਥਾਨ

ਕਈ ਸਟੂਡੀਓਜ਼ ਵਿੱਚ ਗੇਮਪਲੇ ਲਾਜ਼ਿਕ—ਕ quest, UI ਨਿਯਮ, ਟ੍ਰਿੱਗਰ—ਲਈ ਸਕ੍ਰਿਪਟਿੰਗ ਭਾਸ਼ਾਵਾਂ ਵਰਤੀ ਜਾਂਦੀਆਂ ਹਨ ਕਿਉਂਕਿ ਇਤਰੈਸ਼ਨ ਦੀ ਰਫ਼ਤਾਰ ਮਹੱਤਵਪੂਰਨ ਹੁੰਦੀ ਹੈ। ਇੰਜਣ ਕੋਰ ਆਮ ਤੌਰ 'ਤੇ ਨੇਟਿਵ ਰਹਿੰਦਾ ਹੈ, ਅਤੇ ਸਕ੍ਰਿਪਟਾਂ C/C++ ਸਿਸਟਮਾਂ ਨੂੰ ਬਾਈਂਡਿੰਗ ਰਾਹੀਂ ਕਾਲ ਕਰਦੀਆਂ ਹਨ। ਆਮ ਪੈਟਰਨ: ਸਕ੍ਰਿਪਟਾਂ ਆਰਕੀਸਟਰੇਟ ਕਰਦੀਆਂ ਹਨ; C/C++ ਮਹਿੰਗੇ ਹਿੱਸਿਆਂ ਨੂੰ ਚਲਾਉਂਦੇ ਹਨ।

ਕੰਪਾਇਲਰ, ਟੂਲਚੇਨ ਅਤੇ ਇੰਟਰਓਪ

C ਅਤੇ C++ ਸਿਰਫ਼ "ਦੌੜਦੇ" ਹੀ ਨਹੀਂ—ਉਹਨਾਂ ਨੂੰ ਇੱਕ ਵਿਸ਼ੇਸ਼ CPU ਅਤੇ OS ਲਈ ਨੈਟਿਵ ਬਾਇਨਰੀਜ਼ ਵਿੱਚ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ। ਇਹ ਬਿਲਡ ਪਾਈਪਲਾਈਨ ਇੱਕ ਵੱਡਾ ਕਾਰਨ ਹੈ ਕਿ ਇਹ ਭਾਸ਼ਾਵਾਂ OS, ਡੇਟਾਬੇਸ, ਅਤੇ ਗੇਮ ਇੰਜਣਾਂ ਵਿੱਚ ਕੇਂਦਰੀ ਪ੍ਰਭਾਵ ਰੱਖਦੀਆਂ ਹਨ।

ਬਿਲਡ ਦੌਰਾਨ ਆਮ ਤੌਰ 'ਤੇ ਕੀ ਹੁੰਦਾ ਹੈ

ਇੱਕ ਆਮ ਬਿਲਡ ਵਿੱਚ ਕੁਝ ਪੜਾਅ ਹੁੰਦੇ ਹਨ:

• ਕੰਪਾਇਲਰ: C/C++ ਸੋर्स ਨੂੰ ਮਸ਼ੀਨ-ਨਿਰਧਾਰਿਤ ਆਬਜੈਕਟ ਫਾਇਲਾਂ ਵਿੱਚ ਬਦਲਦਾ ਹੈ।
• ਲਿੰਕਰ: ਆਬਜੈਕਟ ਫਾਇਲਾਂ ਨੂੰ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨਾਲ ਜੋੜ ਕੇ ਏਗਜ਼ਿਕਿਊਟੇਬਲ ਜਾਂ ਸ਼ੇਅਰਡ ਲਾਇਬ੍ਰੇਰੀ ਬਣਾਉਂਦਾ ਹੈ।
• ਬਾਇਨਰੀ ਆਉਟਪੁਟ: ਆਖਰੀ ਆਰਟੀਫੈਕਟ ਜੋ OS ਸਿਧਾ ਲੋਡ ਕਰ ਸਕਦਾ ਹੈ (ਅਕਸਰ ਅਲੱਗ ਡਿਬੱਗ ਸਿੰਬਲਾਂ ਨਾਲ)।

ਲਿੰਕਰ ਪੜਾਅ 'ਚ ਕਈ ਅਸਲ-ਦੁਨੀਆ ਮੁੱਦੇ ਸਾਹਮਣੇ ਆਉਂਦੇ ਹਨ: ਮਿਸਿੰਗ ਸਿੰਬਲ, ਲਾਇਬ੍ਰੇਰੀ ਸੰਸਕਰਨ ਦਾ ਮੇਲ ਨਾ ਹੋਣਾ, ਜਾਂ ਅਣ-ਮੈਚਿੰਗ ਬਿਲਡ ਸੈਟਿੰਗ।

ਕਿਉਂ ਟੂਲਚੇਨ ਅਤੇ ਪਲੇਟਫਾਰਮ ਸਹਿਯੋਗ ਮਹੱਤਵਪੂਰਨ ਹਨ

ਇੱਕ ਟੂਲਚੇਨ ਵਿੱਚ ਕੰਪਾਇਲਰ, ਲਿੰਕਰ, ਸਟੈਂਡਰਡ ਲਾਇਬ੍ਰੇਰੀ, ਅਤੇ ਬਿਲਡ ਟੂਲ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ। ਸਿਸਟਮ ਸਾਫਟਵੇਅਰ ਲਈ ਪਲੇਟਫਾਰਮ ਕਵਰੇਜ ਨਿਰਣায়ক ਹੋ ਸਕਦੀ ਹੈ:

• ਕਨਸੋਲ ਅਤੇ ਮੋਬਾਈਲ SDKs ਵਿਸ਼ੇਸ਼ ਕੰਪਾਇਲਰ/ਲਿੰਕਰ ਲੋੜ ਸਕਦੇ ਹਨ।
• ਡੇਟਾਬੇਸ ਅਤੇ ਬੈਕਐਂਡ ਸਾਫਟਵੇਅਰ ਨੂੰ Linux ਡਿਸਟ੍ਰੋਜ਼ ਅਤੇ CPU ਕਿਸਮਾਂ 'ਤੇ ਸਥਿਰ ਬਿਲਡਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।
• OS ਅਤੇ ਡਰਾਈਵਰ ਕੰਮ ਲਈ ਕ੍ਰਾਸ-ਕੰਪਾਇਲਰ, ਸਖ਼ਤ ਫਲੈਗ, ਅਤੇ ABI ਅਨੁਸ਼ਾਸਨ ਲਾਜ਼ਮੀ ਹੋ ਸਕਦੇ ਹਨ।

ਟੀਮਾਂ ਕਈ ਵਾਰੀ C/C++ ਚੁਣਦੀਆਂ ਹਨ ਕਿਉਂਕਿ ਟੂਲਚੇਨ ਪੱਕੇ ਤੇ ਵਿਆਪਕ ਹਨ—embedded ਡਿਵਾਈਸਾਂ ਤੋਂ ਲੈ ਕੇ ਸਰਵਰਾਂ ਤੱਕ।

ਹੋਰ ਭਾਸ਼ਾਵਾਂ ਨਾਲ ਇੰਟਰਫੇਸ (FFI)

C ਨੂੰ ਅਕਸਰ "ਯੂਨੀਵਰਸਲ ਐਡਾਪਟਰ" ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ। ਕਈ ਭਾਸ਼ਾਵਾਂ C ਫੰਕਸ਼ਨਾਂ ਨੂੰ FFI ਰਾਹੀਂ ਕਾਲ ਕਰ ਸਕਦੀਆਂ ਹਨ, ਇਸ ਲਈ ਟੀਮਾਂ ਅਕਸਰ ਪ੍ਰਦਰਸ਼ਨ-ਨਾਜ਼ੁਕ ਲਾਜਿਕ ਨੂੰ C/C++ ਲਾਇਬ੍ਰੇਰੀ ਵਿੱਚ ਰੱਖਦੀਆਂ ਹਨ ਅਤੇ ਉੱਤੇ ਛੋਟੀ API ਪ੍ਰਦਾਨ ਕਰਦੀਆਂ ਹਨ। ਇਸੀ ਲਈ Python, Rust, Java ਅਤੇ ਹੋਰ ਅਕਸਰ ਮੌਜੂਦਾ C/C++ ਕੰਪੋਨੇਟਾਂ ਨੂੰ ਰੈਪ ਕਰਦੇ ਹਨ, ਨਾਂ ਕਿ ਉਹਨਾਂ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖਦੇ ਹਨ।

ਡੀਬੱਗਿੰਗ ਅਤੇ ਪ੍ਰੋਫਾਈਲਿੰਗ: ਟੀਮਾਂ ਕੀ ਮਾਪਦੇ ਹਨ

C/C++ ਟੀਮਾਂ ਆਮ ਤੌਰ 'ਤੇ ਮਾਪਦੀਆਂ ਹਨ:

• CPU ਸਮਾਂ (ਹੌਟ ਫੰਕਸ਼ਨ, ਕਾਲ ਸਟੈਕ)
• ਮੇਮੋਰੀ ਵਰਤੋ (ਅਲੋਕੇਸ਼ਨ, ਲੀਕ, ਫ੍ਰੈਗਮੇਂਟੇਸ਼ਨ)
• ਲੈਟੈਂਸੀ (ਗੇਮਾਂ ਵਿੱਚ ਫਰੇਮ ਟਾਈਮ, ਡੇਟਾਬੇਸ ਵਿੱਚ ਕੁਐਰੀ ਟਾਈਮ)
• I/O ਵਿਹਾਰ (ਕੈਸ਼ ਮਿਸ, ਡਿਸਕ ਰੀਡ, ਸਿਸਕਾਲ)

ਵਰਕਫਲੋ ਲਗਾਤਾਰ ਹੈ: ਬੋਤਲਨੈਕ ਲੱਭੋ, ਡੇਟਾ ਨਾਲ ਪੁਸ਼ਟੀ ਕਰੋ, ਫਿਰ ਸਭ ਤੋਂ ਛੋਟੀ ਕੰਪੋਨੈਂਟ ਨੂੰ optimize ਕਰੋ ਜੋ ਅਸਲ ਵਿੱਚ ਮਾਇਨੇ ਰੱਖਦੀ ਹੈ।

ਅਜੋਕੇ ਦੌਰ ਵਿੱਚ C/C++ ਚੁਣਨਾ: ਪ੍ਰਾਇਕਟਿਕ ਗਾਈਡ

C ਅਤੇ C++ ਅਜੇ ਵੀ ਬਹੁਤ ਵਧੀਆ ਟੂਲ ਹਨ—ਜਦੋਂ ਤੁਸੀਂ ਐਸਾ ਸਾਫਟਵੇਅਰ ਬਣਾਉਂਦੇ ਹੋ ਜਿਥੇ ਕੁਝ ਮਿਲੀਸੈਕਿੰਡ, ਕੁਝ ਬਾਈਟ, ਜਾਂ ਖਾਸ CPU ਨਿਰਦੇਸ਼ ਅਸਲ ਵਿੱਚ ਮਾਇਨੇ ਰੱਖਦੇ ਹਨ। ਉਹ ਹਰ ਫੀਚਰ ਜਾਂ ਟੀਮ ਲਈ ਡਿਫਾਲਟ ਚੋਣ ਨਹੀਂ ਹਨ।

ਕਦੋਂ C/C++ ਸਹੀ ਚੋਣ ਹਨ

C/C++ ਨੂੰ ਚੁਣੋ ਜਦੋਂ ਕੰਪੋਨੈਂਟ ਪ੍ਰਦਰਸ਼ਨ-ਨਾਜ਼ੁਕ ਹੋ, ਤਿੱਖਾ ਮੇਮੋਰੀ ਕੰਟਰੋਲ ਚਾਹੀਦਾ ਹੋਵੇ, ਜਾਂ ਜਦੋਂ OS/ਹਾਰਡਵੇਅਰ ਨਾਲ ਨੇੜੇ ਇੰਟਿਗ੍ਰੇਸ਼ਨ ਲਾਜ਼ਮੀ ਹੋਵੇ।

ਾਮੂਦਰ ਹਿੱਸੇ:

• ਹਾਟ-ਪਾਥ ਜਿਹੜੀ ਲੈਟੈਂਸੀ ਦਿਸਦੀ ਹੈ (ਪਾਰਸਿੰਗ, ਕੰਪ੍ਰੈਸ਼ਨ, ਰੇੰਡਰਿੰਗ, ਕੁਐਰੀ ਐਕਜ਼ਿਕਿਊਸ਼ਨ)
• ਨੀਵੀਂ-ਸਤਹ ਮਾਡਿਊਲ ਜਿਹੜੇ ਪੇਸ਼ਗੋਈਯੋਗ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ (ਅਲੋਕੇਟਰ, ਸ਼ਡਿਊਲਰ, ਨੈੱਟਵਰਕਿੰਗ ਪ੍ਰimitives)
• ਕ੍ਰਾਸ-ਪਲੇਟਫਾਰਮ ਲਾਇਬ੍ਰੇਰੀਆਂ ਜਿੱਥੇ ਨੇਟਿਵ ਕੋਡ ਸਹੀ ਉਤਪਾਦ ਹੈ (SDKs, ਇੰਜਣ, ਐਮਬੈੱਡਿਡ)
• ਜਦੋਂ ਕੰਪਾਇਲਰ/ਟੂਲਚੇਨ ਪਾਰਥਰਾਂ 'ਤੇ ਪੋਰਟੇਬਿਲਿਟੀ ਲਾਜ਼ਮੀ ਹੋਵੇ

ਕਦੋਂ ਹੋਰ ਭਾਸ਼ਾਵਾਂ ਪਸੰਦ ਕਰੋ

ਉੱਚ-ਸਤਹ ਭਾਸ਼ਾ ਚੁਣੋ ਜਦੋਂ ਪ੍ਰਾਥਮਿਕਤਾ ਸੁਰੱਖਿਆ, ਇਟਰੈਸ਼ਨ ਰਫ਼ਤਾਰ, ਜਾਂ ਵੱਡੇ ਪੱਧਰ 'ਤੇ বজ਼-ਬਹਾਲ ਰੱਖਣਾ ਹੋਵੇ।

ਇਸਦਾ ਅਰਥ ਹੈ ਕਿ Rust, Go, Java, C#, Python, ਜਾਂ TypeScript ਵਰਗੀਆਂ ਭਾਸ਼ਾਵਾਂ ਦਾ ਚੋਣ ਉਹਨਾਂ ਵੇਲੇ ਬੇਤਰ ਹੁੰਦਾ ਹੈ ਜਦੋਂ:

• ਟੀਮ ਵੱਡੀ ਹੋਵੇ ਅਤੇ ਟਰਨਓਵਰ ਉਮੀਦ ਕੀਤੀ ਜਾਵੇ (ਘੱਟ ਫੁੱਟ-ਗਨ
• ਫੀਚਰ ਤੇਜ਼ੀ ਨਾਲ ਬਦਲਦੇ ਰਹਿਣ ਅਤੇ ਸਹੀਤਾ ਸਿੱਰਫ਼ ਕੁੱਲ ਨਾਲੋਂ ਵੱਧ ਮਹੱਤਵਪੂਰਨ ਹੋਵੇ
• ਤੁਹਾਨੂੰ ਮਜ਼ਬੂਤ ਮੇਮੋਰੀ-ਸੁਰੱਖਿਆ ਗੈਰੰਟੀ ਚਾਹੀਦੀ ਹੋਵੇ
• ਡਿਵੈਲਪਰ ਪ੍ਰੋਡਕਟੀਵਟੀ ਅਤੇ ਹਾਇਰਿੰਗ ਪੂਲ ਕੱਚੀ ਰਫ਼ਤਾਰ ਤੇਜ਼ੀ ਨਾਲ ਮਹੱਤਵਪੂਰਨ ਹੋ

ਅਮਲੀ ਤੌਰ 'ਤੇ, ਜ਼ਿਆਦਾਤਰ ਪ੍ਰੋਡਕਟ ਮਿਕਸ ਹੁੰਦੇ ਹਨ: ਪ੍ਰਦਰਸ਼ਨ-ਨਾਜ਼ੁਕ ਕੋਰ ਲਈ ਨੇਟਿਵ ਲਾਇਬ੍ਰੇਰੀਆਂ, ਅਤੇ ਹੋਰ ਸੇਵਾਵਾਂ ਅਤੇ UI ਲਈ ਉੱਚ-ਸਤਹ ਭਾਸ਼ਾਵਾਂ।

ਐਪ ਟੀਮਾਂ ਲਈ ਪ੍ਰਾਇਕਟਿਕ ਨੋਟ (ਜਿੱਥੇ Koder.ai ਫਿੱਟ ਹੁੰਦਾ ਹੈ)

ਜੇ ਤੁਸੀਂ ਮੁੱਖ ਤੌਰ 'ਤੇ ਵੈੱਬ, ਬੈਕਐਂਡ, ਜਾਂ ਮੋਬਾਈਲ ਫੀਚਰ ਬਣਾ ਰਹੇ ਹੋ, ਤਾਂ ਆਮ ਤੌਰ 'ਤੇ ਤੁਹਾਨੂੰ C/C++ ਲਿਖਣ ਦੀ ਲੋੜ ਨਹੀਂ ਹੁੰਦੀ—ਤੁਸੀਂ ਇਸਦਾ ਲਾਭ ਆਪਣੇ OS, ਡੇਟਾਬੇਸ, ਰਨਟਾਈਮ ਅਤੇ ਡਿਪੈਂਡੇੰਸੀਜ਼ ਦੇ ਰਾਹੀਂ ਲੈਂਦੇ ਹੋ। Platforms ਜਿਵੇਂ Koder.ai ਇਸ ਵੰਡ ਨੂੰ ਸਵਾਲੀ ਰਖਦੀਆਂ ਹਨ: ਤੁਸੀਂ ਚੈਟ-ਚਾਲਿਤ ਵਰਕਫਲੋ ਨਾਲ ਤੇਜ਼ੀ ਨਾਲ React ਵੈੱਬ ਐਪ, Go + PostgreSQL ਬੈਕਐਂਡ, ਜਾਂ Flutter ਮੋਬਾਈਲ ਐਪ ਤਿਆਰ ਕਰ ਸਕਦੇ ਹੋ, ਅਤੇ ਜ਼ਰੂਰਤ ਪੈਣ 'ਤੇ ਮੌਜੂਦਾ C/C++ ਲਾਇਬ੍ਰੇਰੀ ਵਿੱਚੋਂ ਇੱਕ FFI ਬਾਊਂਡਰੀ ਰਾਹੀਂ ਕਾਲ ਕਰਕੇ ਨੇਟਿਵ ਕੰਪੋਨੈਂਟ ਸ਼ਾਮਿਲ ਕਰ ਸਕਦੇ ਹੋ। ਇਸ ਨਾਲ ਉਤਪਾਦ ਸਤਹ ਦਾ ਜ਼ਿਆਦਾ ਹਿੱਸਾ ਤੇਜ਼ ਇਟਰੇਸ਼ਨ ਵਾਲੇ ਕੋਡ ਵਿੱਚ ਰਹਿੰਦਾ ਹੈ, ਜਦੋਂ ਕਿ ਜਿੱਥੇ ਨੇਟਿਵ ਕੋਡ ਸਹੀ ਉਪਕਾਰ ਹੈ ਉਸਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ।

ਪ੍ਰਾਇਕਟਿਕ ਚੈੱਕਲਿਸਟ (ਕੰਪੋਨੇਟ-ਨੂੰ-ਕੰਪੋਨੇਟ)

ਇਕੋ ਬਾਰ ਫੈਸਲਾ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਇਹ ਸਵਾਲ ਪੁੱਛੋ:

1. ਕੀ ਇਹ ਨਿਰਧਾਰਤ ਪਾਥ 'ਤੇ ਹੈ? ਪਹਿਲਾਂ ਮਾਪੋ; ਅੰਦਾਜ਼ਾ ਨਾ ਲਗਾਓ।
2. ਫੇਲਯੋਗ ਮੋਡ ਕੀ ਹਨ? C/C++ ਵਿੱਚ ਮੇਮੋਰੀ ਕਰਪਸ਼ਨ ਨਾਸ਼ਨਾਕ ਹੋ ਸਕਦੀ ਹੈ।
3. ਇੰਟਰਫੇਸ ਬਾਊਂਡਰੀ ਕੀ ਹੈ? ਕੀ ਤੁਸੀਂ ਨੇਟਿਵ ਕੋਡ ਨੂੰ ਇੱਕ ਛੋਟੀ API ਪਿੱਛੇ ਵਿਭਾਜਿਤ ਕਰ ਸਕਦੇ ਹੋ?
4. ਕੀ ਤੁਹਾਡੇ ਕੋਲ ਮਹਿਰਤ ਹੈ? ਸਮੀਖਿਆ, ਟੈਸਟਿੰਗ, ਅਤੇ ਪ੍ਰੋਫਾਈਲਿੰਗ ਨੈਣ-ਹਟਾਸ਼ ਹਨ।
5. ਡਿਪਲੋਇਮੈਂਟ ਲਕਸ਼ ਕੀ ਹੈ? ਕਨਸੋਲ, ਐਮਬੈੱਡਿਡ, ਕਰਨਲ, ਅਤੇ ਡਰਾਈਵਰ ਹੁਣ-ਹੀ C/C++ ਨੂੰ ਤਰਜੀਹ ਦੇ ਸਕਦੇ ਹਨ।
6. ਤੁਸੀਂ ਇਸਨੂੰ ਕਿਵੇਂ ਟੈਸਟ ਅਤੇ ਪ੍ਰੋਫਾਈਲ ਕਰੋਗੇ? ਸ਼ੁਰੂ ਤੋਂ ਹੀ ਟੂਲਿੰਗ ਅਤੇ CI ਦੀ ਯੋਜਨਾ ਬਣਾਓ।

ਅਗਲੇ ਪੜ੍ਹਨ ਲਈ ਸੁਝਾਅ

• Performance profiling basics
• Memory leaks and how to find them
• Pricing

ਨਿਸ਼ਕਰਸ਼

C ਅਤੇ C++ ਅਜੇ ਵੀ ਉਹ ਔਜਾਰ ਹਨ ਜੋ ਨੀਵੀਂ-ਸਤਹ ਕੰਪੋਨੈਂਟਾਂ ਨੂੰ ਛੋਟੇ ਅਦਾਂ ਅਤੇ ਤੇਜ਼ੀ ਨਾਲ ਚਲਾਉਣ ਲਈ ਜ਼ਰੂਰੀ ਕੰਟਰੋਲ ਦਿੰਦੇ ਹਨ। ਉਹ ਹਰ ਸਮੇਂ ਦੀ ਦਫ਼ਤਰ-ਵਿਹਾਰ ਦੀ ਭਾਸ਼ਾ ਨਹੀਂ—ਪਰ ਜਿੱਥੇ ਹਾਰਡਵੇਅਰ, ਮੇਮੋਰੀ ਅਤੇ ਲੈਟੈਂਸੀ ਅਤਿ-ਅਹੰਕਾਰਕ ਹਨ, ਉਥੇ ਇਹ ਭਾਸ਼ਾਵਾਂ ਆਪਣਾ ਥਾਂ ਬਰਕਰਾਰ ਰੱਖਦੀਆਂ ਹਨ।

ਅਧਿਕਤਰ ਪ੍ਰੋਜੈਕਟਾਂ ਲਈ ਪ੍ਰਯੋਗਤਮ ਦਿਸ਼ਾ ਇਹ ਹੈ: ਪ੍ਰਦਰਸ਼ਨ-ਕ੍ਰੀਟੀਕਲ ਕੋਰ ਨੇਟਿਵ ਵਿੱਚ ਰੱਖੋ ਅਤੇ ਪ੍ਰੋਡਕਟ ਫੀਚਰਾਂ ਲਈ ਤੇਜ਼ ਇਟਰੈਸ਼ਨ ਵਾਲੀਆਂ ਅਤੇ ਜ਼ਿਆਦਾ ਸੁਰੱਖਿਅਤ ਭਾਸ਼ਾਵਾਂ ਵਰਤੋ।

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