Fabrice Bellard ਦੀ ਪਰਫਾਰਮੈਂਸ ਕਾਰੀਗਰੀ: FFmpeg \u0026 QEMU ਤੋਂ ਸਬਕ

ਕਿਉਂ Fabrice Bellard ਉਹਨਾਂ ਟੀਮਾਂ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ ਜੋ ਪਰਫਾਰਮੈਂਸ 'ਤੇ ਧਿਆਨ ਦਿੰਦੇ ਹਨ

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

ਇਸ ਲੇਖ ਦਾ ਮਕਸਦ ਉਹਨਾਂ ਚੋਣਾਂ ਤੇ ਵਿਹਾਰਕ ਨਜ਼ਰ ਰੱਖਣਾ ਹੈ ਜਿਨ੍ਹਾਂ ਨੇ ਉਸ ਪ੍ਰਭਾਵ ਨੂੰ ਪੈਦਾ ਕੀਤਾ। ਨਾ ਕੋਈ ਮਿਥ, ਨਾ "ਜੀਨੀਅਸ ਕਹਾਣੀਆਂ", ਅਤੇ ਨਾ ਹੀ ਅਜਿਹੇ অসমਬਲੀ ਹਿਲ-ਟ੍ਰਿਕਸ ਦੀ ਸੈਰ। ਬਲਕਿ ਅਸੀਂ ਉਹ ਗੱਲਾਂ ਵੇਖਾਂਗੇ ਜੋ ਪਰਫਾਰਮੈਂਸ-ਮੇਨਡ ਟੀਮਾਂ ਲਈ ਫਾਇਦੇਮੰਦ ਹਨ: ਸਹੀ ਸੀਮਾਵਾਂ ਕਿਵੇਂ ਰੱਖਣੀਆਂ, ਪ੍ਰਗਟ ਕਰੋ ਕਿ ਕਿਵੇਂ ਤਰੱਕੀ ਨੂੰ ਮਾਪਿਆ ਜਾਵੇ, ਅਤੇ ਕਿਵੇਂ ਤੇਜ਼ੀ ਵਾਲੇ ਸੁਧਾਰ ਇਸ ਤਰ੍ਹਾਂ ਲਾਉਣ ਜੋ ਕੋਡਬੇਸ ਨੂੰ ਨਾਜੁਕ ਨਹੀਂ ਬਣਾਉਂਦੇ।

ਇੱਥੇ "ਪਰਫਾਰਮੈਂਸ ਕਾਰੀਗਰੀ" ਦਾ ਕੀ ਮਤਲਬ ਹੈ

"ਪਰਫਾਰਮੈਂਸ ਕਾਰੀਗਰੀ" ਨਾਲ ਅਸੀਂ ਮਤਲਬ ਰੱਖਦੇ ਹਾਂ ਕਿ ਤੇਜ਼ੀ ਤੇ ਕੁशलਤਾ ਨੂੰ ਇੰਜੀਨੀਅਰਿੰਗ ਗੁਣਵੱਤਾ ਦੇ ਪਹਿਲੇ ਦਰਜੇ ਦਾ ਹਿਸਾ ਮੰਨਿਆ ਜਾਏ—ਸਹੀ ਹੋਣ, ਰੱਖ-ਰਖਾਅ ਯੋਗ ਹੋਣ ਅਤੇ ਉਪਯੋਗਿਤਾ ਦੇ ਨਾਲ ਇੱਕੱਠੇ।

ਇਸ ਵਿੱਚ ਸ਼ਾਮِل ਹੈ:

• ਸੋਚ-ਵਿਚਾਰ ਕੇ ਤਰਜੀحات ਕਰਨਾ (ਤੇਜ਼ ਅਤੇ ਸਹੀ, ਨਾ ਕਿ ਤੇਜ਼ ਜਾਂ ਸਹੀ)
• ਐਸੇ ਸਿਸਟਮ ਡਿਜ਼ਾਇਨ ਕਰਨਾ ਜਿੱਥੇ ਪਰਫਾਰਮੈਂਸ ਸਾਫਟਵੇਅਰ ਦੀ ਸੰਰਚਨਾ ਤੋਂ ਆਵੇ, ਮੌਕੇ ਤੋਂ ਨਹੀਂ
• ਕੰਮ ਨੂੰ ਦਿਸ਼ਾ ਦੇਣ ਲਈ ਮਾਪ-ਤਰੀਕਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰਨੀ, ਅਨੁਭਵ 'ਤੇ ਨਿਰਭਰ ਰਹਿਣ ਦੀ ਥਾਂ
• ਐਸੇ ਸੁਧਾਰ ਨਿਕਾਲਨਾ ਜੋ ਹੋਰ ਲੋਕਾਂ ਲਈ ਨਿਰਮਾਣਯੋਗ ਹੋਣ

ਅਹਿਮ ਗੱਲ: ਕਾਰੀਗਰੀ ਦੁਹਰਾਈ ਜਾ ਸਕਦੀ ਹੈ। ਤੁਸੀਂ ਉਹ ਅਭਿਆਸ ਅਪਣਾ ਸਕਦੇ ਹੋ ਬਿਨਾਂ ਕਿਸੇ ਇਕ ਵਾਰ ਦੀ ਮਹਾਨ ਵਿਅਕਤੀ ਦੀ ਲੋੜ ਦੇ।

ਦੋ ਕੇਸ-ਸਟਡੀਜ਼ ਜਿਨ੍ਹਾਂ ਤੋਂ ਤੁਸੀਂ ਲਾਭ ਚੁਕ ਸਕਦੇ ਹੋ

ਅਸੀਂ ਦੋ Bellard-ਸਬੰਧੀ ਪ੍ਰਾਜੈਕਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ ਜੋ ਅਸਲੀ ਸੀਮਾਵਾਂ ਹੇਠਾਂ ਪਰਫਾਰਮੈਂਸ ਸੋਚ ਦਿਖਾਉਂਦੇ ਹਨ:

• FFmpeg, ਜਿਸ ਨੇ ਉੱਚ-ਗੁਣਵੱਤਾ ਆਡੀਓ/ਵੀਡੀਓ ਪ੍ਰੋਸੈਸਿੰਗ ਨੂੰ ਉਹਨਾ ਤੱਕ ਤੇਜ਼ ਕੀਤਾ ਕਿ ਇਹ ਹਰਰੋਜ਼ ਸਾਫਟਵੇਅਰ ਲਈ ਪ੍ਰਯੋਗਯੋਗ ਹੋ ਗਿਆ।
• QEMU, ਜਿਸ ਨੇ ਵਰਚੁਅਲਾਈਜੇਸ਼ਨ ਅਤੇ ਇਮੂਲੇਸ਼ਨ ਨੂੰ ਆਮ ਹਾਰਡਵੇਅਰ 'ਤੇ ਵਰਤਣ ਯੋਗ ਬਣਾਇਆ, ਇਸ ਨਾਲ ਅਜਿਹੇ ਵਰਕਫਲੋ ਨਾਰਮਲ ਮਹਿਸੂਸ ਹੁੰਦੇ ਨੇ।

ਇਹ ਕਿਸ ਲਈ ਹੈ

ਇਹ ਲਿਖਤ ਉਨ੍ਹਾਂ ਲਈ ਹੈ:

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

ਜੇ ਤੁਹਾਡੀ ਟੀਮ ਐਸਾ ਸੌਫਟਵੇਅਰ ਭੇਜਦੀ ਹੈ ਜੋ ਸਕੇਲ ਤੇ ਚਲਦਾ ਹੈ—ਜਾਂ ਸੰਕੁਚਿਤ ਡਿਵਾਈਸਾਂ 'ਤੇ—ਤਾਂ Bellard ਦਾ ਕੰਮ ਇਹ ਦਿਖਾਉਂਦਾ ਹੈ ਕਿ ਅਮਲੀ ਤੌਰ 'ਤੇ "ਗੰਭੀਰ ਪਰਫਾਰਮੈਂਸ" ਕਿਵੇਂ ਲੱਗਦੀ ਹੈ।

ਇਕ ਇੰਜੀਨੀਅਰ, ਬਹੁਤ ਸਾਰੇ ਗੁਣਕ: ਇੱਕ ਵਾਸਤਵਿਕ ਨਜ਼ਰੀਆ

Fabrice Bellard ਨੂੰ ਅਕਸਰ ਪਰਫਾਰਮੈਂਸ ਇੰਜੀਨੀਅਰਿੰਗ ਸਪੇਅਰ ਵਿੱਚ ਹਵਾਲੇ ਦੇ ਤੌਰ 'ਤੇ ਲਿਆ ਜਾਂਦਾ ਹੈ ਕਿਉਂਕਿ ਉਸਦੇ ਕੁਝ ਪ੍ਰਾਜੈਕਟਾਂ ਨੇ "ਕਾਫ਼ੀ ਤੇਜ਼" ਨੂੰ ਹਰਰੋਜ਼ ਦੀਆਂ ਮਸ਼ੀਨਾਂ 'ਤੇ ਆਮ ਕਰ ਦਿੱਤਾ। ਮੁੱਖ ਉਦਾਹਰਣ ਹਨ FFmpeg (ਉੱਚ-ਕਾਰਗਰ ਆਡੀਓ/ਵੀਡੀਓ ਪ੍ਰੋਸੈਸਿੰਗ) ਅਤੇ QEMU (ਵਰਚੁਅਲਾਈਜ਼ੇਸ਼ਨ ਅਤੇ CPU ਇਮੂਲੇਸ਼ਨ)। ਉਸ ਨੇ Tiny C Compiler (TCC) ਬਣਾਇਆ ਅਤੇ QuickJS ਵਰਗੇ ਪ੍ਰਾਜੈਕਟਾਂ 'ਚ ਯੋਗਦਾਨ ਦਿੱਤਾ। ਹਰ ਇੱਕ ਵਿੱਚ ਅਮਲੀ ਤੇਜ਼ੀ, ਛੋਟਾ ਫੁੱਟਪ੍ਰਿੰਟ ਅਤੇ ਖੁੱਲ੍ਹਾ ਮਾਪਦੰਡ ਦੀ ਪਸੰਦ ਸਾਫ਼ ਦਿਸਦੀ ਹੈ।

ਇਕ ਵਿਅਕਤੀ ਕੀ ਕਰ ਸਕਦਾ ਹੈ (ਅਤੇ ਕੀ ਨਹੀਂ)

ਇਕਲੇ ਹੀ 'ਜੀਨੀਅਸ' ਕਹਾਣੀ ਨੂੰ ਸਿਮੇਟਣਾ ਆਕਰਸ਼ਕ ਹੈ। ਹਕੀਕਤ ਜ਼ਿਆਦਾ ਉਪਯੋਗੀ ਹੈ: Bellard ਦੀਆਂ ਸ਼ੁਰੂਆਤੀ ਡਿਜ਼ਾਇਨਾਂ, ਪ੍ਰੋਟੋਟਾਈਪ ਅਤੇ ਪਰਫਾਰਮੈਂਸ ਫੈਸਲੇ ਦਿਸ਼ਾ ਨਿਰਧਾਰਤ ਕਰਦੇ ਹਨ, ਪਰ ਇਹ ਪ੍ਰਾਜੈਕਟ ਇਸ ਲਈ ਟਿਕੇ ਕਿ ਕਮਿਊਨਿਟੀਆਂ ਨੇ ਉਹਨਾਂ ਨੂੰ बनाए ਰੱਖਿਆ, ਵਧਾਇਆ, ਸਮੀਖਿਆ ਕੀਤੀ ਅਤੇ ਪੋਰਟ ਕੀਤਾ।

ਹਕੀਕਤੀ ਵੰਡ ਇਸ ਤਰ੍ਹਾਂ ਦਿਸਦੀ ਹੈ:

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

ਓਪਨ ਸੋর্স ਕਿਵੇਂ ਕੋਸ਼ਿਸ਼ ਨੂੰ ਗੁਣਾ ਕਰਦਾ ਹੈ

ਓਪਨ-ਸੋਰਸ ਇਕ ਵਿਅਕਤੀ ਦੇ ਵਧੀਆ ਵਿਚਾਰ ਨੂੰ ਸਾਂਝੀ ਬੇਨਚਮਾਰਕ ਬਣਾਉਂਦਾ ਹੈ। ਜਦੋਂ FFmpeg ਮੀਡੀਆ ਪਾਈਪਲਾਈਨ ਲਈ ਡੀਫਾਲਟ ਟੂਲਚੇਨ ਬਣ ਜਾਂਦਾ ਹੈ, ਜਾਂ QEMU ਸਿਸਟਮ ਚਲਾਉਣ ਅਤੇ ਟੈਸਟ ਕਰਨ ਦਾ ਇੱਕ ਮਿਆਰੀ ਤਰੀਕਾ ਬਣ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਹਰ ਪਲੈਟਰ adopters ਦੀ ਗਿਣਤੀ ਅਪਰੋਕਸੀਮਟ ਹੋ ਕੇ: ਬੱਗ ਰਿਪੋਰਟ, ਅਪਟੀਮਾਈਜ਼ੇਸ਼ਨ, ਬਿਲਡ ਫਿਕਸ ਅਤੇ ਐੱਜ-ਕੇਸ ਵੈਰੀਫਿਕੇਸ਼ਨ ਦਿੰਦੇ ਹਨ। ਗ੍ਰਹਿਣ ਲੈਂਦੇ ਜਾਣਾ ਗੁਣਾ ਬਣ ਜਾਂਦਾ ਹੈ।

ਉਹ ਸ਼ੁਰੂਆਤੀ-ਹਾਰਡਵੇਅਰ ਸੀਮਾ ਜਿਸ ਨੇ ਇਸ ਕਾਰੀਗਰੀ ਨੂੰ ਆਕਾਰ ਦਿੱਤਾ

ਕਈ ਇਹ ਪ੍ਰਾਜੈਕਟ ਉਸ ਵੇਲੇ ਵਿਕਸਤ ਹੋਏ ਜਦੋਂ CPU ਧੀਮੇ ਸਨ, ਮੈਮੋਰੀ ਸੀਮਿਤ ਸੀ, ਅਤੇ "ਸਿਰਫ਼ ਵੱਡੀ ਮਸ਼ੀਨ ਲਾ ਦਿਓ" ਜ਼ਿਆਦਾਤਰ ਉਪਭੋਗਤਾਵਾਂ ਲਈ ਚੋਣ ਨਹੀਂ ਸੀ। ਕੁਸ਼ਲਤਾ ਕੋਈ ਸੁੰਦਰੀ ਚੋਣ ਨਹੀਂ ਸੀ—ਇਹ ਵਰਤੋਂਯੋਗਤਾ ਸੀ।

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

FFmpeg: ਪਰਫਾਰਮੈਂਸ ਨੂੰ ਇੱਕ ਉਤਪਾਦ ਫੀਚਰ ਬਣਾਉਣਾ

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

ਕਿਉਂ ਮੀਡੀਆ ਵਰਕਲੋਡ ਸਸਤੀਆਂ ਕੋਡ ਨੂੰ ਸਜ਼ਾ ਦਿੰਦੀਆਂ ਹਨ

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

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

ਸਟੈਂਡਰਡ, ਕੋਡੈਕ ਅਤੇ ਅਨੁਕੂਲਤਾ ਇੱਕ ਪਰਫਾਰਮੈਂਸ ਲੋੜ ਹਨ

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

ਜਦੋਂ ਇੱਕ ਟੂਲ ਇੰਫਰਾਸਟਰੱਕਚਰ ਬਣ ਜਾਂਦਾ ਹੈ

ਕਿਉਂਕਿ FFmpeg ਵਰਤਣਯੋਗ ਹੈ— ਸਕ੍ਰਿਪਟਯੋਗ, ਆਟੋਮੇਟਬਲ, ਅਤੇ ਹਰ ਜਗ੍ਹਾ ਉਪਲਬਧ—ਇਹ ਉਹ ਮੀਡੀਆ ਲੇਅਰ ਬਣ ਜਾਂਦਾ ਹੈ ਜਿਸ ਨੂੰ ਹੋਰ ਸਿਸਟਮ ਮੰਨ ਲੈਂਦੇ ਹਨ। ਟੀਮਾਂ ਡੀਕੋਡਰ ਮੁੜ-ਨਿਰਮਾਣ ਨਹੀਂ ਕਰਦੀਆਂ; ਉਹ ਵਰਕਫਲੋਜ਼ ਰਚਦੀਆਂ ਹਨ।

ਤੁਸੀਂ ਆਮ ਤੌਰ 'ਤੇ FFmpeg ਨੂੰ ਇਹਨਾਂ ਥਾਵਾਂ ਵਿੱਖੋਂ ਮਿਲਾ ਕਰੋਗੇ:

• ਵੀਡੀਓ ਐਡੀਟਿੰਗ ਅਤੇ ਪਲੇਬੈਕ ਐਪ
• ਸਰਵਰ-ਸਾਈਡ ਟਰਾਂਸਕੋਡਿੰਗ ਪਾਈਪਲਾਈਨ VOD ਅਤੇ ਲਾਈਵ ਸਟ੍ਰੀਮਿੰਗ ਲਈ
• ਬ੍ਰਾਉਜ਼ਰ/ਡੈਸਕਟਾਪ ਐਪ ਜਿਹੜੇ ਪ੍ਰੀਵਿਊ, ਥੰਬਨੈਲ ਅਤੇ ਵੇਵਫਾਰਮ ਬਣਾਉਂਦੇ ਹਨ
• CCTV/ਮਾਨੀਟਰਿੰਗ ਸਿਸਟਮ ਜੋ ਲਗਾਤਾਰ ਰਿਕਾਰਡਿੰਗ ਸੰਭਾਲਦੇ ਹਨ
• ML ਪਾਈਪਲਾਈਨ ਜੋ ਵੀਡੀਓ ਫਰੇਮ ਤੇਜ਼ੀ ਨਾਲ ਲੋਡ ਕਰਨ ਦੀ ਲੋੜ ਰੱਖਦੇ ਹਨ

ਇਹ "ਸ਼ਾਂਤ" ਯੂਬਿਕਵਿਟੀ ਮਕਸਦ ਹੀ ਹੈ: ਪਰਫਾਰਮੈਂਸ, ਸਹੀਪਣ ਅਤੇ ਅਨੁਕੂਲਤਾ FFmpeg ਨੂੰ केवल ਇੱਕ ਲਾਇਬ੍ਰੇਰੀ ਨਹੀਂ, ਸਗੋਂ ਇੱਕ ਅਧਾਰ ਬਣਾਉਂਦੇ ਹਨ ਜਿਸ 'ਤੇ ਹੋਰ ਸੁਰੱਖਿਅਤ ਤਰੀਕੇ ਨਾਲ ਨਿਰਭਰ ਕਰ ਸਕਦੇ ਹਨ।

FFmpeg ਦੀ ਕਾਰਗਰਤਾ ਮਨੋਵਿਰਤ (ਅਸੈਂਬਲੀ ਡੀਪ-ਡਾਈਵ ਤੋਂ ਬਿਨਾਂ)

FFmpeg ਪਰਫਾਰਮੈਂਸ ਨੂੰ "ਉਤਪਾਦ ਦਾ ਹੀ ਹਿੱਸਾ" ਮੰਨਦਾ ਹੈ, ਬਾਅਦ ਦਾ ਪਾਲਿਕਾ ਨਹੀਂ। ਮੀਡੀਆ ਕੰਮ ਵਿੱਚ ਪਰਫਾਰਮੈਂਸ ਸਮੱਸਿਆਵਾਂ ਸਪਸ਼ਟ ਹੁੰਦੀਆਂ ਹਨ: ਤੁਸੀਂ ਕਿੰਨੇ ਫਰੇਮ ਪ੍ਰਤੀ ਸਕਿੰਟ ਡਿਕੋਡ/ਐਨਕੋਡ ਕਰ ਸਕਦੇ ਹੋ (ਥਰੂਪੁੱਟ), ਪਲੇਬੈਕ ਕਿੰਨੀ ਤੇਜ਼ ਸਟਾਰਟ ਹੁੰਦੀ ਹੈ ਜਾਂ ਸਕ੍ਰੱਬਿੰਗ ਕਿਵੇਂ ਜਵਾਬ ਦਿੰਦੀ ਹੈ (ਲੇਟੈਂਸੀ), ਅਤੇ ਕਿੰਨਾ CPU ਖਰਚ ਹੁੰਦਾ ਹੈ (ਜੋ ਬੈਟਰੀ, ਕਲਾਉਡ ਲਾਗਤ, ਅਤੇ ਫੈਨ ਆਵਾਜ਼ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ)।

ਉਸ ਜਗ੍ਹਾ ਨੂੰ ਅਪਟੀਮਾਈਜ਼ ਕਰੋ ਜਿੱਥੇ ਅਸਲ ਸਮਾਂ ਲੱਗਦਾ ਹੈ

ਮੀਡੀਆ ਪਾਈਪਲਾਈਨ ਇੱਕ ਹੀ ਛੋਟੀ-ਸੈੱਟ ਓਪਰੇਸ਼ਨਾਂ ਨੂੰ ਬਾਰ-ਬਾਰ ਕਰਦੇ ਹਨ: ਮੋਸ਼ਨ ਐਸਟਿਮੇਸ਼ਨ, ਟ੍ਰਾਂਸਫਾਰਮ, ਪਿਕਸਲ ਫਾਰਮੈਟ ਬਦਲੀ, ਰੀਸੈਂਪਲਿੰਗ, ਬਿੱਟਸਟ੍ਰੀਮ ਪਾਰਸਿੰਗ। FFmpeg ਦੀ ਸੰਸਕ੍ਰਿਤੀ ਇਹ ਹੈ ਕਿ ਉਹ ਇਹਨਾਂ ਹਾਟਸਪੌਟਾਂ ਦੀ ਪਛਾਣ ਕਰਦਾ ਅਤੇ ਫਿਰ ਵੀ■■■■

• ਆਮ ਹਾਲਤਾਂ ਲਈ ਫास्ट ਪਾਥ (ਲੋਕਪ੍ਰਿਯ ਪਿਕਸਲ ਫਾਰਮੇਟ, ਆਮ ਰਿਜ਼ੋਲਿਊਸ਼ਨ, ਅਲਾਈਨਡ ਬਫਰ)
• ਲੋੜ ਨਾਂ ਹੋਣ 'ਤੇ ਕੰਮ ਨਾ ਕਰਨਾ (ਕਾਪੀ, ਬਦਲਾਅ, ਵਾਧੂ ਪਾਸ)
• ਡੇਟਾ ਨੂੰ ਪੇਸ਼ਗੀ ਤੌਰ 'ਤੇ ਹਿਲਾਉਣਾ ਤਾਂ ਕਿ CPU ਇੱਕੋ ਜਿਹਾ ਲੂਪ ਲੱਖਾਂ ਵਾਰ ਇੱਕਸਾਰ ਚਲਾ ਸਕੇ

ਤੁਹਾਨੂੰ ਅਸੈਂਬਲੀ ਪੜ੍ਹਨ ਦੀ ਲੋੜ ਨਹੀਂ ਕਿ ਪੁਝੇ ਪਾਤਰ: ਜੇ ਕੋਈ ਲੂਪ ਹਰ ਫਰੇਮ ਦੇ ਹਰ ਪਿਕਸਲ ਲਈ ਚਲਦਾ ਹੈ, ਇੱਕ ਛੋਟੀ ਸੁਧਾਰ ਵੱਡਾ ਲਾਭ ਬਣ ਜਾਂਦਾ ਹੈ।

ਤਰਜੀحات ਸਪਸ਼ਟ ਹੁੰਦੀਆਂ ਹਨ, ਨਾ ਕਿ ਅਕਸਮੀ

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

ਪੋਰਟੇਬਿਲਟੀ ਇਕ ਪਰਫਾਰਮੈਂਸ ਲੋੜ ਵੀ ਹੈ

ਇੱਕ ਤੇਜ਼ ਹੱਲ ਜੋ ਸਿਰਫ਼ ਇੱਕ CPU 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ ਉਹ ਅਰਧ-ਹੱਲ ਹੈ। FFmpeg ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਇਹ ਕਈ OS ਅਤੇ ਇੰਸਟ੍ਰਕਸ਼ਨ ਸੈਟਾਂ 'ਤੇ ਚੰਗਾ ਚਲੇ—ਇਸਦਾ ਮਤਲਬ ਹੈ ਸਾਫ਼ ਫਾਲਬੈਕ ਅਤੇ ਰਨਟਾਈਮ 'ਤੇ ਸਭ ਤੋਂ ਚੰਗੀ ਇੰਪਲੀਮੇਟੇਸ਼ਨ ਚੁਣਨ ਦੀ ਯੋਜਨਾ।

ਬੈਂਚਮਾਰਕ ਫੈਸਲੇ ਗਾਈਡ ਕਰਦੇ ਹਨ (ਧਿਆਨ ਨਾਲ)

FFmpeg ਵਿੱਚ ਬੈਂਚਮਾਰਕ ਅਮਲਕਾਰੀ ਸਵਾਲਾਂ ਦਾ ਜਵਾਬ ਦਿੰਦੇ ਹਨ—"ਕੀ ਇਹ ਅਸਲ ਇੰਪੁਟਾਂ 'ਤੇ ਤੇਜ਼ ਹੈ?"—ਨ ਕਿ ਸਰਵਸ ਨੰਬਰ ਦਾ ਵਚਨ। ਚੰਗੀਆਂ ਟੈਸਟਾਂ ਤਦਨੁਸਾਰ ਸਮਾਨ ਸੈਟਿੰਗਾਂ ਦੀ ਤੁਲਨਾ ਕਰਦੀਆਂ ਹਨ, ਹਾਰਡਵੇਅਰ ਫ਼ਰਕਾਂ ਮੰਨਦੀਆਂ ਹਨ, ਅਤੇ ਮਾਰਕੀਟਿੰਗ-ਗਰੇਡ ਦਾਅਵਿਆਂ ਦੀ ਥਾਂ ਦੁਹਰਾਏ ਜਾਣ ਯੋਗ ਸੁਧਾਰਾਂ 'ਤੇ ਧਿਆਨ ਕਰਦੀਆਂ ਹਨ।

QEMU: ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਨੂੰ ਯਥਾਰਥ ਅਤੇ ਤੇਜ਼ ਬਣਾਉਣਾ

QEMU ਇੱਕ ਟੂਲ ਹੈ ਜੋ ਇੱਕ ਕੰਪਿਊਟਰ ਨੂੰ ਦੂਜੇ ਕੰਪਿਊਟਰ ਦੀ ਤਰ੍ਹਾਂ ਚਲਾਉਣ ਦਿੰਦਾ ਹੈ—ਯਾ ਤਾਂ ਇਮੂਲੇਸ਼ਨ ਰਾਹੀਂ (ਤਾਂ ਜੋ ਤੁਸੀਂ ਇੱਕ ARM ਇਮੇਜ ਨੂੰ x86 ਲੈਪਟਾਪ 'ਤੇ ਚਲਾ ਸਕੋ), ਜਾਂ ਵਰਚੁਅਲਾਈਜ਼ੇਸ਼ਨ ਰਾਹੀਂ (ਜਿੱਥੇ ਗੈਸਟ ਹੋਸਟ ਦੇ CPU ਫੀਚਰਾਂ ਨੂੰ ਸਾਂਝਾ ਕਰਦਾ ਹੈ ਅਤੇ ਨੇਅਰ-ਨੈਟਿਵ ਸਪੀਡ ਮਿਲਦੀ ਹੈ)।

ਜੇ ਇਹ ਜਾਦੂ ਵਰਗਾ ਲੱਗਦਾ ਹੈ, ਤਾਂ ਇਸ ਦਾ ਕਾਰਨ ਇਹ ਹੈ ਕਿ ਲਕੜੀ ਖਾਸ ਤੌਰ 'ਤੇ ਮੁਸ਼ਕਲ ਹੈ: ਤੁਸੀਂ ਸਾਫਟਵੇਅਰ ਨੂੰ ਪੂਰੇ ਕੰਪਿਊਟਰ ਦੀ ਨਕਲ ਕਰਨ ਲਈ ਕਹਿ ਰਹੇ ਹੋ—CPU ਹੁਕਮ, ਮੈਮੋਰੀ, ਡਿਸਕ, ਟਾਈਮਰ, ਨੈੱਟਵਰਕ ਕਾਰਡ ਅਤੇ ਬੇਸ਼ੁਮਾਰ ਐੱਜ-ਕੇਸ—ਜਦੋਂ ਕਿ ਇਹ ਤੇਜ਼ ਰਹੇ ਤਾਂ ਹੀ ਵਰਤੋਂਯੋਗ ਬਣਦਾ ਹੈ।

ਇਮੂਲੇਸ਼ਨ ਵਿ. ਵਰਚੁਅਲਾਈਜ਼ੇਸ਼ਨ (ਸਧਾਰਨ ਸ਼ਬਦਾਂ ਵਿੱਚ)

• ਇਮੂਲੇਸ਼ਨ: "ਦੂਜੇ ਕੰਪਿਊਟਰ ਵਾਂਗ ਵਰਤੋ"। ਚੰਗਾ ਹੈ ARM ਇਮੇਜ ਨੂੰ x86 'ਤੇ ਚਲਾਉਣ ਲਈ, ਜਾਂ ਪੁੁਰਾਣਾ ਸਿਸਟਮ ਮੁੜ ਬਣਾਉਣ ਲਈ। ਇਹ ਲਚਕੀਲਾ ਹੈ, ਪਰ ਤੇਜ਼ ਬਣਾਉਣਾ ਔਖਾ ਹੁੰਦਾ ਹੈ।
• ਵਰਚੁਅਲਾਈਜ਼ੇਸ਼ਨ: "ਉਹੀ ਕਿਸਮ ਦੇ CPU ਉੱਤੇ ਗੈਸਟ OS ਚਲਾਓ"। ਜਦੋਂ ਇਹ KVM ਵਰਗੇ ਕੇਰਨਲ ਸਹਿਯੋਗ ਨਾਲ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ, QEMU ਕਈ CPU ਕੰਮ ਹੋਸਟ ਨੂੰ ਦੇ ਸਕਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਦਿਨ-ਪ੍ਰਤੀਕ ਕਰਨ ਲਈ ਕਾਰਗਰਤਾ ਮਿਲਦੀ ਹੈ।

ਇੱਥੇ ਕਾਰਗਰਤਾ ਕਿਉਂ ਜ਼ਰੂਰੀ ਹੈ

ਧੀਮੀ VM ਸਿਰਫ਼ ਖਟਕਾਉਣ ਵਾਲੀ ਨਹੀਂ; ਉਹ ਵਰਕਫਲੋਜ਼ ਨੂੰ ਰੋਕ ਦਿੰਦੀ ਹੈ। QEMU ਦਾ ਪਰਫਾਰਮੈਂਸ ਧਿਆਨ ਇਹ ਬਦਲ ਦਿੰਦਾ ਹੈ ਕਿ "ਅਸੀਂ ਕਦੇ ਟੈਸਟ ਕਰਾਂਗੇ" ਤੋਂ "ਅਸੀਂ ਹਰ ਕਮਿੱਟ 'ਤੇ ਟੈਸਟ ਕਰ ਸਕਦੇ ਹਾਂ"। ਇਹ ਟੀਮਾਂ ਦੇ ਸੌਫਟਵੇਅਰ ਜਾਰੀ ਕਰਨ ਦੇ ਢੰਗ ਬਦਲ ਦਿੰਦਾ ਹੈ।

ਮੁੱਖ ਨਤੀਜੇ:

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

QEMU ਵਰਚੁਅਲਾਈਜ਼ੇਸ਼ਨ ਸਟੈਕ ਵਿੱਚ ਕਿੱਥੇ ਫਿੱਟ ਹੁੰਦਾ ਹੈ

QEMU ਅਕਸਰ ਉਹ "ਐੰਜਿਨ" ਹੁੰਦਾ ਹੈ ਜੋ ਉੱਚ-ਸਤਰ ਟੂਲਾਂ ਦੇ ਥੱਲੇ ਚੱਲਦਾ ਹੈ। ਆਮ ਜੋੜੀਆਂ ਵਿੱਚ KVM ਤੇ libvirt/virt-manager ਸ਼ਾਮਿਲ ਹਨ। ਕਈ ਵਾਤਾਵਰਣਾਂ ਵਿੱਚ, ਕਲਾਉਡ ਪਲੇਟਫਾਰਮ ਅਤੇ VM ਆਰਕੀਟੈਕਚਰਿੰਗ ਟੂਲ QEMU 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ।

ਟੀਮਾਂ ਦਰਅਸਲ ਕਿੱਥੇ ਵਰਤਦੀਆਂ ਉਦਾਹਰਨਾਂ

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

QEMU ਦੀ ਅਸਲੀ ਕਾਮਯਾਬੀ ਇਹ ਨਹੀਂ ਕਿ ਇੱਕ VM ਸੰਦ ਮੌਜੂਦ ਹੈ। ਇਸ ਦੀ ਕਾਮਯਾਬੀ ਇਹ ਹੈ ਕਿ ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ ਐਨਾਸੇ ਪ੍ਰਯੋਗਯੋਗ ਅਤੇ ਸਹੀ ਹਨ ਕਿ ਟੀਮਾਂ ਉਨ੍ਹਾਂ ਨੂੰ ਦੈਨੀਕ ਇੰਜੀਨੀਅਰਿੰਗ ਦਾ ਹਿੱਸਾ ਮੰਨ ਸਕਦੇ ਹਨ।

QEMU ਕਿਵੇਂ ਤੇਜ਼ੀ, ਸਹੀਪਣ ਅਤੇ ਲਚੀਲਪਣ ਨੂੰ ਸੰਤੁਲਿਤ ਕਰਦਾ ਹੈ

QEMU ਇੱਕ ਅਜਿਹੇ ਅਸਹਜ ਚੌਂਉਕ 'ਤੇ ਬੈਠਦਾ ਹੈ: ਇਹ "ਕਿਸੇ ਹੋਰ ਦਾ ਕੰਪਿਊਟਰ" ਤੇਜ਼ੀ ਨਾਲ ਚਲਾਉਣਾ, ਭਰੋਸੇਯੋਗ ਹੋਣਾ ਅਤੇ ਕਈ CPU ਕਿਸਮਾਂ ਅਤੇ ਡਿਵਾਈਸਾਂ ਦਾ ਸਹਿਯੋਗ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹੈ। ਇਹ ਲੱਛਣ ਇਕ-ਦੂਜੇ ਨਾਲ ਟਕਰਾਉਂਦੇ ਹਨ, ਅਤੇ QEMU ਦੀ ਡਿਜ਼ਾਇਨ ਇਹ ਦਿਖਾਉਂਦੀ ਹੈ ਕਿ ਤਰਜੀحات ਨੂੰ ਕਿਵੇਂ ਸੰਭਾਲਣਾ ਹੈ।

ਪ੍ਰਦਰਸ਼ਨ ਕਿਵੇਂ translation ਅਤੇ execution 'ਤੇ ਨਿਰਭਰ ਹੁੰਦਾ ਹੈ

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

ਇਹ ਪਰਫਾਰਮੈਂਸ ਧਿਆਨ ਆਰਕੀਟੈਕਚਰ ਵੀ ਹੈ: "ਫਾਸਟ ਪਾਥ" ਨੂੰ ਛੋਟਾ ਅਤੇ ਭਵਿੱਖਵਾਣੀਯੋਗ ਰੱਖੋ, ਅਤੇ ਗ਼ੈਰ-ਆਮ ਜਟਿਲਤਾ ਨੂੰ ਹਾਟ ਲੂਪ ਤੋਂ ਬਾਹਰ ਧੱਕੋ।

ਸਹੀਪਣ ਅਤੇ ਨਿਰਧਾਰਿਤਤਾ ਵਿਕਲਪ ਨਹੀਂ ਹਨ

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

ਨਿਰਧਾਰਿਤਤਾ ਵੀ ਅਹਿਮ ਹੈ। ਜੇ ਉਹੀ ਇੰਪੁੱਟ ਕਈ ਵਾਰੀ ਵੱਖ-ਵੱਖ ਨਤੀਜੇ ਪੈਦਾ ਕਰਦਾ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਬੱਗ ਨੂੰ ਭਰੋਸੇਯੋਗ ਢੰਗ ਨਾਲ ਦੁਹਰਾਉਣ ਨਹੀਂ ਕਰ ਸਕਦੇ। QEMU ਦੇ ਸਾਵਧਾਨ ਡਿਵਾਈਸ ਮਾਡਲ ਅਤੇ ਸੁਪਸ਼ਟ ਐਗਜ਼ਿਕਿਊਸ਼ਨ ਵਿਹਾਰ ਦੌਰਾਨ ਦੌੜਾਂ ਨੂੰ ਦੁਹਰਾਏ ਜਾਣਯੋਗ ਬਣਾਉਂਦੇ ਹਨ, ਜੋ CI ਅਤੇ ਫੇਲਿਓਰਾਂ ਦੀ ਡਾਇਗਨੋਸਿਸ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।

ਲੰਬੇ ਸਮੇਂ ਲਈ ਤੇਜ਼ੀ ਕਰਦੇ ਰਹਿਣ ਵਾਲੀ ਆਰਕੀਟੈਕਚਰ

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

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

ਕਾਰੀਗਰੀ ਲੂਪ: ਮਾਪੋ, ਸਮਝੋ, ਸੁਧਾਰੋ, ਦੁਹਰਾਓ

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

ਕਦਮ 1: ਦੁਹਰਾਏ ਜਾਣਯੋਗ ਟੈਸਟਾਂ ਨਾਲ ਮਾਪੋ

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

ਇੱਕ ਚੰਗੀ ਆਦਤ ਹੈ:

• ਇੱਕ ਐਂਡ-ਟੂ-ਐਂਡ ਬenchਮਾਰ্ক ਰੱਖੋ ਜੋ ਅਸਲ ਵਰਤੋਂ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੋਵੇ
• ਇੱਕ ਛੋਟਾ ਮਾਈਕ੍ਰੋ-ਬenchਮਾਰਕ ਰੱਖੋ ਜੋ ਉਸ ਇੱਕ ਫੰਕਸ਼ਨ ਲਈ ਹੋਵੇ ਜਿਸ ਨੂੰ ਤੁਸੀਂ ਸ਼ੱਕ ਕਰਦੇ ਹੋ ਕਿ ਮਹਿੰਗਾ ਹੈ

ਕਦਮ 2: ਪ੍ਰੋਫਾਈਲਿੰਗ ਰਾਹੀਂ ਸਮਝੋ (ਹਾਟਸਪੌਟ ਪਹਿਲਾਂ)

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

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

ਕਦਮ 3: ਸੁਧਾਰੋ, ਫਿਰ ਮੁੜ-ਮਾਪੋ (ਅਤੇ “ਚੰਗੇ” ਨੰਬਰਾਂ 'ਤੇ ਸੰਦੇਹ)

ਮਾਈਕ੍ਰੋ-ਬenchਮਾਰਕ ਕਿਸੇ ਵਿਸ਼ੇਸ਼ ਵਿਚਾਰ ਦੀ ਪੁਸ਼ਟੀ ਕਰਨ ਲਈ ਵਧੀਆ ਹਨ (ਜਿਵੇਂ "ਕੀ ਇਹ ਪਾਰਸਰ ਤੇਜ਼ ਹੈ?")। ਐਂਡ-ਟੂ-ਐਂਡ ਬenchਮਾਰਕ ਦੱਸਦੇ ਹਨ ਕਿ ਉਪਭੋਗਤਾ ਨੂੰ ਫਰਕ ਮਹਿਸੂਸ ਹੋਏਗਾ ਕਿ ਨਹੀਂ। ਦੋਹਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਪਰ ਦੋਹਾਂ ਨੂੰ ਗੁੰਝਲਦਾਰ ਨਾ ਕਰੋ: 20% ਮਾਈਕ੍ਰੋ-ਵਿਨ ਅਸਲ ਦੁਨੀਆ ਵਿੱਚ 0% ਸੁਧਾਰ ਹੋ ਸਕਦਾ ਹੈ ਜੇ ਉਹ ਕੋਡ ਪਾਥ ਕਦੇ ਹੀ ਵੱਡੀ ਵਾਰ ਨਹੀਂ ਚੱਲਦਾ।

ਭਰਮਕ metrics ਤੋਂ ਵੀ ਸਾਵਧਾਨ ਰਹੋ: ਤੇਜ਼ ਥਰੂਪੁੱਟ ਜੋ ਗਲਤੀ ਦੀ ਦਰ ਵਧਾ ਦੇ, ਘੱਟ CPU ਜੋ ਮੈਮੋਰੀ ਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਭਰ ਦੇ, ਜਾਂ ਇੱਕ ਮਸ਼ੀਨ ਤੇ ਦਿਖਣ ਵਾਲੀ ਜਿੱਤ ਜੋ ਹੋਰਾਂ ਤੇ ਨਹੀਂ ਦਿਖਦੀ। ਲੂਪ ਤਦ ਤੱਕ ਕੰਮ ਕਰਦਾ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਸਹੀ ਚੀਜ਼ ਨੂੰ ਲਗਾਤਾਰ ਮਾਪਦੇ ਹੋ।

ਸਧਾਰਨਤਾ ਇਕ ਪਰਫਾਰਮੈਂਸ ਰਣਨੀਤੀ ਵਜੋਂ

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

ਅਹਿਮ ਰਸਤੇ ਨੂੰ ਬਿਲਕੁਲ ਸਧਾਰਨ ਰੱਖੋ

ਪਰਫਾਰਮੈਂਸ ਕੰਮ ਤਦ کامیاب ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਇੱਕ ਟਾਈਟ ਲੂਪ, ਇੱਕ ਸਨਿ###োল ਡੇਟਾ ਫਲੋ ਜਾਂ ਕੁਝ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਨਿਸ਼ਾਨਾ ਬਣਾ ਕੇ ਕਹ ਸਕਦੇ ਹੋ, "ਇੱਥੇ ਸਮਾਂ ਲੱਗਦਾ ਹੈ।" ਸਧਾਰਣ ਡਿਜ਼ਾਇਨ ਇਹ ਸੰਭਵ ਬਣਾਉਂਦੇ ਹਨ।

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

ਸਾਫ਼ ਇੰਟਰਫੇਸ ਅਪਟੀਮਾਈਜ਼ੇਸ਼ਨ ਨੂੰ ਸੁਰੱਖਿਅਤ ਬਣਾਉਂਦੇ ਹਨ

ਵਧੀਆ-ਪਰਿਭਾਸ਼ਤ ਇੰਟਰਫੇਸ ਸਿਰਫ਼ ਪੜ੍ਹਨਯੋਗਤਾ ਲਈ ਨਹੀਂ; ਉਹ ਪਰਫਾਰਮੈਂਸ ਟੂਲ ਵੀ ਹਨ।

ਜਦੋਂ ਮੋਡੀਊਲਾਂ ਦੀਆਂ ਜ਼ਿੰਮੇਵਾਰੀਆਂ ਅਤੇ ਬਾਊਂਡਰੀ ਸਥਿਰ ਹੋਣ, ਤੁਸੀਂ ਇੱਕ ਮੋਡੀਊਲ ਦੇ ਅੰਦਰ ਅਪਟੀਮਾਈਜ਼ ਕਰ ਸਕਦੇ ਹੋ ਬਿਨਾਂ ਹੋਰ ਥਾਂ ਤੇ ਅਚਾਨਕ ਪ੍ਰਭਾਵ ਪਾਏ। ਤੁਸੀਂ ਇੱਕ ਇੰਪਲੀਮੇਟੇਸ਼ਨ ਬਦਲ ਸਕਦੇ, ਡੇਟਾ ਸਟ੍ਰਕਚਰ ਠੇਠ-ਠਾਹਰ ਕਰ ਸਕਦੇ ਜਾਂ ਇੱਕ ਫਾਸਟ-ਪਾਥ ਜੋੜ ਸਕਦੇ ਹੋ ਅਤੇ ਵਿਹਾਰ ਬਣੀ ਰਹਿੰਦਾ है। ਇਹ ਬenchਮਾਰਕਿੰਗ ਨੂੰ ਵੀ ਮਕਬੂਲ ਬਣਾਉਂਦਾ ਹੈ: ਤੁਸੀਂ ਇੱਕੋ-ਜਿਹੀ ਚੀਜ਼ ਦੀ ਤੁਲਨਾ ਕਰ ਰਹੇ ਹੁੰਦੇ ਹੋ।

ਸਧਾਰਨਤਾ ਯੋਗਦਾਨਕਾਰੀਆਂ (ਅਤੇ ਭਵਿੱਖ ਦੇ ਤੁਹਾਡਾ) ਤੱਕ ਸਕੇਲ ਕਰਦੀ ਹੈ

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

ਇਹ ਛੋਟੀ ਟੀਮਾਂ ਲਈ ਵੀ ਅਹਿਮ ਹੈ। ਸਭ ਤੋਂ ਤੇਜ਼ ਕੋਡ ਉਹ ਹੈ ਜਿਸਨੂੰ ਤੁਸੀਂ ਨਿਰਭਯਤਾ ਨਾਲ ਸੋਧ ਸਕਦੇ ਹੋ—ਕਿਉਂਕਿ ਪਰਫਾਰਮੈਂਸ ਕਦੇ ਖਤਮ ਨਹੀਂ ਹੁੰਦਾ।

ਪਿੱਟਫਾਲ: ਚਤੁਰ ਕੋਡ ਜੋ ਨਾਜੁਕ ਬਣ ਜਾਵੇ

ਕੁਝ "ਅਪਟੀਮਾਈਜ਼ੇਸ਼ਨ" ਹਕੀਕਤ ਵਿੱਚ ਪਹੇਲੀ ਹੁੰਦੀਆਂ ਹਨ:

• ਕੁਝ ਚੱਕਰ ਜੋ ਕੁਝ ਸਾਈਕਲ ਬਚਾਂਦੇ ਹਨ ਪਰ ਨੀਅਤ ਛੁਪਾ ਦਿੰਦੇ ਹਨ
• ਹੱਥ ਨਾਲ ਬਣਾਇਆ ਗਿਆ ਜਟਿਲਤਾ ਜੋ ਕੰਪਾਇਲਰ ਜਾਂ ਲਾਇਬ੍ਰੇਰੀ ਸੌਂਪ ਸਕਦੀ ਹੈ
• ਖ਼ਾਸ-ਮਾਮਲੇ ਦੀਆਂ ਪਰਤਾਂ ਜੋ ਅਜੇਹੀ ਬਣ ਜਾਂਦੀਆਂ ਹਨ ਕਿ ਕਿਸੇ ਨੂੰ ਨਹੀਂ ਪਤਾ ਕਿ ਕਿਹੜਾ ਰਸਤਾ ਸਹੀ ਹੈ

ਚਤੁਰਾਈ ਕਦੇ-ਕਦੇ ਇੱਕ ਬੈਂਚਮਾਰਕ ਜਿੱਤ ਸਕਦੀ ਹੈ ਪਰ ਹਰ ਰੱਖ-ਰਖਾਅ ਚੱਕਰ 'ਚ ਹਾਰ ਜਿੱਤਦੀ ਹੈ। ਬਿਹਤਰ ਲਕੜਾ ਸਧਾਰਣ ਕੋਡ ਹੈ ਜਿਸਦੇ ਹਾਟਸਪੌਟ ਸਪਸ਼ਟ ਹਨ—ਤਾਂ ਜੋ ਸੁਧਾਰ ਦੁਹਰਾਏ ਜਾ ਸਕਣ, ਸਮੀਖਿਆਯੋਗ ਹੋਣ ਅਤੇ ਸਥਿਰ ਰਹਿਣ।

ਆਪਣੀ ਟੀਮ 'ਤੇ ਸਬਕ ਲਾਗੂ ਕਰਨ ਲਈ ਪ੍ਰਯੋਗਿਕ ਖੇਡ-ਪੁਸਤਕ

Bellard ਦਾ ਕੰਮ ਯਾਦ ਦਿਵਾਉਂਦਾ ਹੈ ਕਿ ਪਰਫਾਰਮੈਂਸ ਇੱਕ ਇਕ-ਵਾਰੀ "ਇੰਪਟੀਮਾਈਜ਼ੇਸ਼ਨ ਸਪ੍ਰਿੰਟ" ਨਹੀਂ ਹੈ। ਇਹ ਇੱਕ ਉਤਪਾਦ ਫੈਸਲਾ ਹੈ ਜਿਸਦੇ ਸਾਫ਼ ਟੀਚੇ, ਫੀਡਬੈਕ ਲੂਪ ਅਤੇ ਸਧਾਰਨ ਬਿਜਨੈਸ-ਭਾਸ਼ਾ ਵਿੱਚ ਜਿੱਤਾਂ ਸਮਝਾਈਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ।

1) ਇੱਕ ਪਰਫਾਰਮੈਂਸ ਬਜਟ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ (ਜਿਵੇਂ ਤੁਸੀਂ ਪੈਸੇ ਦਾ ਬਜਟ ਕਰਦੇ ਹੋ)

ਇੱਕ ਪਰਫਾਰਮੈਂਸ ਬਜਟ ਮਕਸਦ ਚੀਜ਼ਾਂ ਹਨ—ਟਾਈਮ, CPU, ਮੈਮੋਰੀ, ਨੈੱਟਵਰਕ, ਊਰਜਾ—ਜੋ ਤੁਹਾਡਾ ਉਤਪਾਦ ਸਹਿਣਯੋਗ ਸਮੇਂ ਜਾਂ ਲਾਗਤ ਦੇ ਬਿਨਾਂ ਖਰਚ ਕਰ ਸਕਦਾ ਹੈ।

ਉਦਾਹਰਣ:

• "ਐਪ ਕਾਲਡ ਸਟਾਰਟ ਮਿਡ-ਰੇਂਜ ਡਿਵਾਈਸਾਂ 'ਤੇ 1.5 ਸਕਿੰਟ ਤੋਂ ਘੱਟ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।"
• "ਵੀਡੀਓ ਏਨਕੋਡ X% CPU ਤੋਂ ਘੱਟ ਰਹੇ ਤਾਂ ਕਿ ਲੈਪਟਾਪ ਫੈਨ ਨਾ ਰੰਪ ਹੋਵੇ।"
• "ਹਰ ਰਿਕਵੇਸਟ ਔਸਤ Y ms ਤੋਂ ਘੱਟ ਰਹੇ ਤਾਂ ਕਿ ਸਰਵਰ ਗਿਣਤੀ ਪੂਰਵਾਨੁਮਾਨਯੋਗ ਰਹੇ।"

2) ਉਹ ਟੀਚੇ ਚੁਣੋ ਜੋ ਤੁਹਾਡੇ ਉਤਪਾਦ ਦੀ ਹਕੀਕਤ ਨਾਲ ਮੇਲ ਖਾਂਦੇ ਹਨ

ਕੁਝ ਮੈਟਰਿਕਸ ਚੁਣੋ ਜੋ ਲੋਕ واقعی ਅਨੁਭਵ ਕਰਦੇ ਹਨ ਜਾਂ ਜਿਨ੍ਹਾਂ ਤੇ ਤੁਹਾਨੂੰ ਖਰਚ ਆਉਂਦਾ ਹੈ:

• ਸਟਾਰਟਅਪ ਟਾਈਮ (ਕਨਵਰਜ਼ਨ, ਰਿਟੇਨਸ਼ਨ)
• ਬੈਟਰੀ ਵਰਤੋਂ / ਥਰਮਲ (ਮੋਬਾਈਲ ਸੰਤੁਸ਼ਟੀ, churn)
• ਸਰਵਰ ਲਾਗਤ (ਕਲਾਉਡ ਖਰਚ, ਕੇਪੈਸੀਟੀ ਯੋਜਨਾ)
• FPS / ਲੇਟੈਂਸੀ (ਮੀਡੀਆ, ਗੇਮਿੰਗ, ਰੀਅਲ-ਟਾਈਮ ਸਹਿਯੋਗ)

ਇੱਕ ਵਾਕ ਵਿੱਚ ਟੀਚਾ ਲਿਖੋ, ਫਿਰ ਮਾਪਣ ਦੀ ਵਿਧੀ ਜੁੜੋ।

3) ਸਾਰੇ ਕੋਡਬੇਸ 'ਤੇ ਨਹੀਂ—ਸਿਰਫ ਸਿਖਰਲੇ ਬੋਤਲ-ਗਲਾਸ ਦੋਲਤ ਕਰੋ

ਵਿਆਪਕ ਰੀ-ਫੈਕਟਰਾਂ ਤੋਂ ਬਚੋ "ਤੇਜ਼ੀ ਲਈ"। ਬਦਲੀ ਦੀ ਪ੍ਰਕਿਰਿਆ:

1. ਮੌਜੂਦਾ ਬੇਸਲਾਈਨ ਮਾਪੋ।
2. 1–3 ਸਿਖਰਲੇ ਹਾਟਸਪੌਟ ਪਛਾਣੋ।
3. ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਉਹਨਾਂ ਨੂੰ ਫਿਕਸ ਕਰੋ, ਫਿਰ ਮੁੜ-ਮਾਪੋ।

ਇਹ ਹੀ ਤਰੀਕਾ FFmpeg ਅਤੇ QEMU ਦੀ ਰੂਹ ਦੇ ਬਰਾਬਰ ਵੱਡੇ ਲਾਭ ਘੱਟ ਖਤਰੇ ਨਾਲ ਮਿਲਦੇ ਹਨ।

4) ਪਰਫਾਰਮੈਂਸ ਨੂੰ ਹਿੱਸੇਦਾਰਾਂ ਲਈ ਦਿੱਖਣਯੋਗ ਬਣਾਓ

ਪਰਫਾਰਮੈਂਸ ਦਾ ਕੰਮ ਆਮ ਤੌਰ 'ਤੇ ਘੱਟ ਮੁੱਲਾਂਕਣ ਵਾਲਾ ਰਹਿੰਦਾ ਹੈ ਜਦ ਤੱਕ ਇਹ ਮਾਧੀ ਨਹੀਂ ਹੁੰਦਾ। ਹਰ ਬਦਲਾਅ ਨਾਲ ਜੁੜੋ:

• ਇੱਕ ਪਹਿਲਾਂ/ਬਾਅਦ ਨੰਬਰ,
• ਉਪਭੋਗਤਾ-ਸਮਰਥ ਪ੍ਰਭਾਵ ("ਸਟਾਰਟ 400ms ਤੇਜ਼ ਹੋ ਗਿਆ"),
• ਲਾਗਤ ਪ੍ਰਭਾਵ ("ਸਾਡੇ ਸਭ ਤੋਂ ਵਿਆਸਤ ਐਂਡਪੋਇੰਟ 'ਤੇ -12% CPU").

ਸਾਦਾ ਹਫ਼ਤਾਵਾਰ ਚਾਰਟ ਵੀ ਕਾਫੀ ਹੁੰਦਾ ਹੈ।

5) ਹਲਕਾ ਚੈੱਕਲਿਸਟ (ਆਪਣੇ ਟੀਮ ਡੌਕ 'ਚ ਕਾਪੀ/ਪੇਸਟ ਕਰੋ)

• ਬੇਸਲਾਈਨ ਕੈਪਚਰ ਅਤੇ ਸਾਂਝੀ ਕੀਤੀ ਗਈ
• ਬਜਟ + ਟੀਚਾ ਮੰਨਿਆ ਗਿਆ
• ਪ੍ਰੋਫਾਈਲਿੰਗ ਰਾਹੀਂ ਸ਼ਿਖਰਲਾ ਬੋਤਲ-ਗਲਾਸ ਪੁਸ਼ਟੀ ਕੀਤਾ ਗਿਆ
• ਫਿਕਸ ਛੋਟਾ ਸਕੋਪ ਕੀਤਾ ਗਿਆ, ਰੋਲਬੈਕ ਯੋਜਨਾ ਨਾਲ
• ਰੈਗਰੈਸ਼ਨ ਰੋਕਣ ਲਈ ਗਾਰਡ (ਬenchਮਾਰਕ/ਮਾਨੀਟਰ) ਜੋੜਿਆ ਗਿਆ
• ਨਤੀਜੇ ਉਪਭੋਗੀ + ਲਾਗਤ ਦੇ ਸ਼ਬਦਾਂ ਵਿੱਚ ਰਿਪੋਰਟ ਕੀਤੇ ਗਏ

ਜਿੱਥੇ Koder.ai ਫਿੱਟ ਬੈਠਦਾ ਹੈ (ਜੇ ਤੁਸੀਂ ਤੇਜ਼ ਇਟਰੇਟ ਕਰ ਰਹੇ ਹੋ)

ਜੇ ਤੁਹਾਡੀ ਟੀਮ ਇੱਕ ਤੇਜ਼ ਬਿਲ੍ਡ-ਅਤੇ-ਇਟਰੇਟ ਵਰਕਫਲੋ ਵਰਤ ਰਹੀ ਹੈ—ਖਾਸ ਕਰਕੇ ਪ੍ਰੋਟੋਟਾਈਪਿੰਗ اندرੂਨੀ ਟੂਲ, ਮੀਡੀਆ ਪਾਈਪਲਾਈਨ ਜਾਂ CI ਸ਼ੈਲੀਆਂ—ਤਾਂ Koder.ai ਇਸ "ਕਾਰੀਗਰੀ ਲੂਪ" ਨੂੰ ਸਹਾਰਾ ਦੇ ਸਕਦਾ ਹੈ। Koder.ai ਗੱਲ-ਬਾਤ-ਚਲਾਉਂਦੇ ਯੋਜਨਾ ਫ੍ਰੋਮ ਤੋਂ ਅਸਲ ਐਪ (React ਵੈੱਬ, Go ਬੈਕਐਂਡ ਨਾਲ PostgreSQL, ਅਤੇ Flutter ਮੋਬਾਈਲ) ਬਣਾਉਂਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਤੁਸੀਂ ਤੇਜ਼ੀ ਨਾਲ ਕਾਰਜਕਾਰੀ ਬੇਸਲਾਈਨ ਤਿਆਰ ਕਰ ਸਕਦੇ ਹੋ, ਫਿਰ ਉਪਰੋਕਤ ਅਨੁਸ਼ਾਸਨ ਲਗਾ ਕੇ: ਬenchਮਾਰਕ, ਪ੍ਰੋਫਾਈਲ ਅਤੇ ਮਹੱਤਵਪੂਰਨ ਰਸਤੇ ਤੰਗ ਕਰੋ ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਪ੍ਰੋਟੋਟਾਈਪ ਪ੍ਰੋਡਕਸ਼ਨ ਬਦਲ ਜਾਏ। ਜੇ ਲੋੜ ਹੋਵੇ, ਤੁਸੀਂ ਸਰੋਤ ਕੋਡ ਐਕਸਪੋਰਟ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਆਪਣੀ ਆਮ ਟੂਲਚੇਨ ਵਿੱਚ ਅਪਟੀਮਾਈਜ਼ ਕਰਦੇ ਰਹੋ।

ਕੋਡ ਤੋਂ ਉਦਯੋਗ ਪ੍ਰਭਾਵ: ਇਹ ਪ੍ਰਾਜੈਕਟ ਕਿਵੇਂ ਫੈਲੇ

FFmpeg ਅਤੇ QEMU ਸਿਰਫ਼ ਤੇਜ਼ ਹੋਣ ਕਾਰਨ ਵਿਅਾਪਕ ਨਹੀਂ ਹੋਏ। ਉਹ ਇਸ ਲਈ ਫੈਲੇ ਕਿ ਉਹ ਪੇਸ਼ਗੋਇ ਸਨ: ਉਹੀ ਇੰਪੁੱਟ ਅਕਸਰ ਉਹੀ ਆਉਟਪੁੱਟ ਦਿੰਦੇ, ਅਪਗ੍ਰੇਡ ਆਮ ਤੌਰ 'ਤੇ ਸਹਿਣਯੋਗ ਰਹੇ, ਅਤੇ ਵਿਹਾਰ ਇਸ ਹੱਦ ਤੱਕ ਸਥਿਰ ਰਿਹਾ ਕਿ ਹੋਰ ਟੂਲ ਉਸ 'ਤੇ ਨਿਰਭਰ ਹੋ ਸਕਣ।

ਭਰੋਸਾ ਵਿਸ਼ਵਾਸ ਵੱਲੋਂ ਕਮਾਇਆ ਜਾਂਦਾ ਹੈ

ਓਪਨ-ਸੋਰਸ ਵਿੱਚ, "ਭਰੋਸਾ" ਅਕਸਰ ਦੋ ਚੀਜ਼ਾਂ ਦਾ ਮਤਲਬ ਹੁੰਦਾ ਹੈ: ਇਹ ਅੱਜ ਕੰਮ ਕਰਦਾ ਹੈ, ਅਤੇ ਕੱਲ੍ਹ ਨੂੰ ਤੁਹਾਨੂੰ ਹੈਰਾਨ ਨਹੀਂ ਕਰੇਗਾ।

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

ਅਡਾਪਸ਼ਨ ਫਲਾਈ-ਵ੍ਹੀਲ: ਡੀਫਾਲਟ ਬਣਨਾ

ਜਦੋਂ ਇੱਕ ਟੂਲ ਭਰੋਸੇਯੋਗ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇੱਕ ਅਡਾਪਸ਼ਨ ਫਲਾਈ-ਵ੍ਹੀਲ ਚੱਲ ਪੈਂਦਾ:

• ਵਧੇਰੇ ਉਪਭੋਗਤਾ ਵੱਖ-ਵੱਖ ਫਾਈਲਾਂ, ਡਿਵਾਈਸਾਂ ਅਤੇ ਐੱਜ-ਕੇਸਾਂ 'ਤੇ ਵੱਧ ਜਾਂਚ ਕਰਦੇ ਹਨ।
• ਵਧੇਰੀ ਜਾਂਚ ਨਾਲ ਫਿਕਸ ਆਉਂਦੇ ਹਨ, ਜਿਸ ਨਾਲ ਸਥਿਰਤਾ ਵਧਦੀ ਹੈ।
• ਵਧੀ ਸਥਿਰਤਾ ਇੰਟਿਗਰੇਟਰਾਂ—ਪੈਕੇਜਰ, ਪਲੇਟਫਾਰਮ ਮੈੰਟੇਨਰ ਅਤੇ ਟੂਲ ਲੇਖਕ—ਨੂੰ ਆਕਰਸ਼ਿਤ ਕਰਦੀ ਹੈ।

ਵਕਤ ਦੇ ਨਾਲ, ਟੂਲ ਉਹ ਹੋ ਜਾਂਦਾ ਹੈ "ਜਿਸਦੀ ਹਰ ਕੋਈ ਉਮੀਦ ਕਰਦਾ ਹੈ": ਟਿਊਟੋਰਿਯਲ ਇਸ ਨੂੰ ਹਵਾਲਾ ਕਰਦੇ ਹਨ, ਸਕ੍ਰਿਪਟ ਇਸ ਨੂੰ ਇੰਸਟਾਲ ਮੰਨ ਲੈਂਦੇ ਹਨ, ਅਤੇ ਹੋਰ ਪ੍ਰਾਜੈਕਟ ਇਹ ਨਾਲ ਅਨੁਕੂਲਤਾ ਚੁਣਦੇ ਹਨ ਕਿਉਂਕਿ ਇਹ ਫੈਸਲਾ ਜੋਖਮ ਘਟਾਂਦਾ ਹੈ।

ਸਿਰਫ਼ ਤੇਜ਼ੀ ਹੀ ਨਹੀਂ ਚਲਦੀ; ਪੈਕੇਜਿੰਗ ਅਤੇ ਡੌਕਸ ਵੀ ਚਲਦੀਆਂ ਹਨ

ਸਭ ਤੋਂ ਵਧੀਆ ਕੋਡ ਵੀ ਜੇ ਗ੍ਰਹਿਣਣਾ ਔਖੀ ਹੋਵੇ ਤਾਂ ਰੁਕੀ ਰਹਿੰਦੀ ਹੈ। ਪ੍ਰਾਜੈਕਟ ਤੇਜ਼ੀ ਨਾਲ ਫੈਲਦੇ ਹਨ ਜਦੋਂ:

• ਡੌਕਯੂਮੈਂਟੇਸ਼ਨ ਆਮ ਵਰਕਫਲੋਜ਼ ਸਮਝਾਉਂਦੀ ਹੈ (ਸਿਰਫ਼ ਇੰਟਰਨਲ ਨਹੀਂ)
• ਵੱਖ-ਵੱਖ ਵਾਤਾਵਰਣਾਂ 'ਚ ਪੈਕੇਜਿੰਗ ਸੌਖੀ ਹੋਵੇ
• ਇੰਟర్ఫੇਸ ਯਥਾਰਥ ਤੌਰ 'ਤੇ ਸਥਿਰ ਰਹਿਣ ਤਾਂ ਕਿ ਡਾਊਨਸਟ੍ਰੀਮ ਟੂਲ ਹਰ ਰਿਲੀਜ਼ 'ਤੇ ਟੁੱਟ ਕੇ ਨਾ ਰਹਿਣ

ਇਹ ਆਖਰੀ ਗੱਲ ਘੱਟ ਅੰਕ ਦੀ ਸਮਝੀ ਜਾਂਦੀ ਹੈ: ਸਥਿਰਤਾ ਇੱਕ ਫੀਚਰ ਹੈ। ਟੀਮਾਂ ਅਣਦੇਸ਼ਾਂ ਦੀ ਥਾਂ ਘੱਟ ਹੈਰਾਨੀਆਂ ਲਈ ਅੱਧਿਕ ਤਰਜੀਹ ਦਿੰਦੀਆਂ ਹਨ।

ਕਮਿਊਨਿਟੀਆਂ ਇੱਕ ਮਜ਼ਬੂਤ ਕੋਰ ਨੂੰ ਇਕੋ ਈਕੋਸਿਸਟਮ 'ਚ ਬਦਲ ਦਿੰਦੀਆਂ ਹਨ

ਇੱਕ ਮਹਾਨ ਸ਼ੁਰੂਆਤੀ ਕੋਡਬੇਸ ਦਿਸ਼ਾ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ, ਪਰ ਇੱਕ ਕਮਿਊਨਿਟੀ ਉਸਨੂੰ ਟਿਕाऊ ਬਣਾਉਂਦੀ ਹੈ। ਯੋਗਦਾਨਕਾਰ ਫਾਰਮੈਟ ਸਹਿਯੋਗ ਜੋੜਦੇ ਹਨ, ਕੋਰ ਸ਼ੁਰਤਾਂ ਦੀ ਮੁਰੰਮਤ ਕਰਦੇ ਹਨ, ਪੋਰਟਬਿਲਟੀ ਸੁਧਾਰਦੇ ਹਨ, ਅਤੇ ਰੈਪਰ ਅਤੇ ਇੰਟਿਗਰੇਸ਼ਨ ਬਣਾਉਂਦੇ ਹਨ। Maintainers ਮੁੱਦਿਆਂ ਦੀ ਤਰਤੀਬ ਕਰਦੇ ਹਨ, ਤਰਜੀحات 'ਤੇ ਚਰਚਾ ਕਰਦੇ ਹਨ, ਅਤੇ ਨਿਰਧਾਰਤ ਕਰਦੇ ਹਨ ਕਿ "ਸਹੀ" ਦਾ ਮਤਲਬ ਕੀ ਹੈ।

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

ਮਿਥ, ਗਲਤ ਪਰਛਾਵਾਂ ਅਤੇ ਆਧੁਨਿਕ ਇੰਜੀਨੀਅਰਿੰਗ ਲਈ ਨਿਸ਼ਕਰਸ਼

Bellard ਦੇ ਕੰਮ ਨੂੰ ਦੇਖ ਕੇ ਇਹ ਨਤੀਜਾ ਕੱਢਣਾ ਆਸਾਨ ਹੈ: "ਸਾਨੂੰ ਸਿਰਫ਼ ਇਕ ਜੀਨੀਅਸ ਚਾਹੀਦਾ ਹੈ।" ਇਹ ਸਭ ਤੋਂ ਆਮ ਗਲਤ ਸਮਝ ਹੈ—ਅਤੇ ਨਾ صرف ਗਲਤ, ਬਲਕਿ ਹਾਨਿਕਾਰਕ ਵੀ। ਇਹ ਪਰਫਾਰਮੈਂਸ ਨੂੰ ਹੀਰੋ ਵਸ਼ੀਕਰਨ ਤੇ ਰੱਖਦਾ ਹੈ ਬਜਾਏ ਇੱਕ ਇੰਜੀਨੀਅਰਿੰਗ ਅਨੁਸ਼ਾਸਨ ਦੇ।

ਮਿਥ: ਇੱਕ ਵਿਅਕਤੀ ਉਤਪਾਦ ਨੂੰ ਬਚਾ ਸਕਦਾ/ਚਾਹੀਦਾ ਹੈ

ਹਾਂ, ਇੱਕ ਇੰਜੀਨੀਅਰ ਵੱਡੀ ਲੀਵਰੇਜ ਪੈਦਾ ਕਰ ਸਕਦਾ ਹੈ। ਪਰ FFmpeg ਅਤੇ QEMU ਵਰਗੇ ਪ੍ਰਾਜੈਕਟਾਂ ਦੀ ਅਸਲੀ ਕਹਾਣੀ ਦੁਹਰਾਏ ਜਾਣਯੋਗ ਹੈ: ਤਿੱਘੀ ਫੀਡਬੈਕ ਲੂਪ, ਸੋਚ-ਵਿਚਾਰ ਫੈਸਲੇ, ਅਤੇ ਮੰਨਣ ਦੀ ਤਿਆਰੀ। ਜਿਹੜੀਆਂ ਟੀਮਾਂ "ਬਚਾਉਣ ਵਾਲੇ" ਦੀ ਉਡੀਕ ਕਰਦੀਆਂ ਹਨ ਉਹ ਅਕਸਰ ਉਹ ਨਿਰਾਸ਼ਰੂਪ ਕੰਮ ਛੱਡ ਦਿੰਦੇ ਹਨ ਜੋ ਹਕੀਕਤ ਵਿੱਚ ਤੇਜ਼ੀ ਪੈਦਾ ਕਰਦਾ ਹੈ: ਮਾਪ, ਗਾਰਡਰੇਲ ਅਤੇ ਰੱਖ-ਰਖਾਵ।

ਟੀਮਾਂ ਕੀ ਸਿਖ ਸਕਦੀਆਂ ਹਨ ਬਿਨਾਂ ਕਿਸੇ ਸੁਪਰਸਟਾਰ ਨੂੰ ਕਲੋਨ ਕੀਤੇ

ਤੁਹਾਨੂੰ ਉਹ ਵਿਅਕਤੀ ਨਹੀਂ ਚਾਹੀਦਾ ਜੋ ਸਿਸਟਮ ਦੇ ਹਰ ਕੋਨੇ ਦੀ ਜਾਣਕਾਰੀ ਰੱਖਦਾ ਹੋਵੇ। ਤੁਹਾਨੂੰ ਇੱਕ ਟੀਮ ਚਾਹੀਦੀ ਹੈ ਜੋ ਪਰਫਾਰਮੈਂਸ ਨੂੰ ਇੱਕ ਸਾਂਝੇ ਉਤਪਾਦੀ ਮੰਗ ਵਜੋਂ ਮੰਨੇ।

ਇਸਦਾ ਮਤਲਬ ਹੈ:

• ਹਾਟ ਪਾਥਾਂ ਲਈ ਸਪਸ਼ਟ ਮਿਲਕियत (ਜਦ ਪਰਫਾਰਮੈਂਸ ਖਰਾਬ ਹੋਵੇ ਤਾਂ ਕੌਣ ਜਾਗੇਗਾ?)
• ਕੋਡ ਸਮੀਖਿਆ ਨਿਯਮ ਜੋ "ਕੀ ਲਾਗਤ ਹੈ?" ਨੂੰ "ਕੀ ਇਹ ਸਹੀ ਹੈ?" ਦੇ ਨਾਲ ਪੁੱਛਣ
• ਪਰਫਾਰਮੈਂਸ ਟੈਸਟ ਜੋ ਫੰਕਸ਼ਨਲ ਟੈਸਟਾਂ ਵਾਂਗ ਦੌੜਦੇ ਹਨ: ਰੋਟੀਨ, ਆਟੋਮੈਟਿਕ ਅਤੇ ਥਰੈਸ਼ੋਲਡ ਨਾਲ

ਪਰਫਾਰਮੈਂਸ ਸਭਿਆਚਾਰ ਬਣਾਉਣ ਵਾਲੀਆਂ ਆਦਤਾਂ

ਬੇਸਲਾਈਨ ਨਾਲ ਸ਼ੁਰੂਆਤ ਕਰੋ। ਜੇ ਤੁਸੀਂ ਨਹੀਂ ਕਹਿ ਸਕਦੇ "ਇਸ ਦੀ ਅੱਜ ਕਿਵੇਂ ਤੇਜ਼ੀ ਹੈ", ਤਾਂ ਤੁਸੀਂ ਇਹ ਨਹੀਂ ਕਹਿ ਸਕਦੇ ਕਿ ਤੁਸੀਂ ਉਸਨੂੰ ਸੁਧਾਰਿਆ।

ਉਪਯੋਗ ਕਰੋ ਰੈਗਰੈਸ਼ਨ ਅਲਰਟ ਜੋ ਮਹੱਤਵਪੂਰਨ ਮੈਟਰਿਕਸ (ਲੇਟੈਂਸੀ ਪਰਸੈਂਟਾਈਲ, CPU ਟਾਈਮ, ਮੈਮੋਰੀ, ਸਟਾਰਟਅਪ ਟਾਈਮ) 'ਤੇ ਟ੍ਰਿੱਗਰ ਹੁੰਦੇ ਹਨ। ਉਨ੍ਹਾਂ ਨੂੰ ਕਾਰਵਾਈਯੋਗ ਰੱਖੋ: ਅਲਰਟ ਕਮਿੱਟ ਰੇਂਜ, ਬenchਮਾਰਕ ਅਤੇ ਸ਼ੱਕ ਕੀਤੇ ਸਬਸਿਸਟਮ ਵੱਲ ਨਿਰਦੇਸ਼ ਕਰੇ।

ਰਿਲੀਜ਼ ਨੋਟਾਂ ਵਿੱਚ ਪਰਫਾਰਮੈਂਸ ਬਦਲਾਅ ਸ਼ਾਮਿਲ ਕਰੋ—ਚੰਗੇ ਜਾਂ ਮੰਦੇ। ਇਸ ਨਾਲ ਇਹ ਆਮ ਹੋ ਜਾਂਦਾ ਹੈ ਕਿ ਤੇਜ਼ੀ ਇੱਕ ਦਿੱਤੀ ਜਾਨ ਵਾਲੀ ਚੀਜ਼ ਹੈ, ਇੱਕ ਸਾਈਡ-ਇਫੈਕਟ ਨਹੀਂ।

ਨਿਸ਼ਕਰਸ਼

ਕਾਰੀਗਰੀ ਇੱਕ ਰਵੱਈਆ ਹੈ, ਇੱਕ ਸ਼ਖਸੀਅਤ ਨਹੀਂ। Bellard ਦੀ ਸਭ ਤੋਂ ਉਪਯੋਗੀ ਸਿੱਖਿਆ ਇਹ ਨਹੀਂ ਕਿ ਇੱਕ ਮਹਾਨ ਇੰਜੀਨੀਅਰ ਲੱਭੋ—ਇਹ ਹੈ ਕਿ ਇੱਕ ਟੀਮ ਬਣਾਓ ਜੋ ਮਾਪਦੀ, ਸਿਖਦੀ, ਤੇ ਜਨਤਕ ਢੰਗ ਨਾਲ ਲਗਾਤਾਰ ਸੁਧਾਰ ਕਰਦੀ ਰਹੇ।