John Hennessy ਦੇ ਪਰਫਾਰਮੈਂਸ ਸਕੇਲਿੰਗ ਲਈ ਆਰਕੀਟੈਕਚਰ ਵਿਚਾਰ

ਕਿਉਂ Hennessy ਆਧੁਨਿਕ ਪਰਫਾਰਮੈਂਸ ਲਈ ਅਜੇ ਵੀ ਮਹੱਤਵਪੂਰਨ ਹਨ

John Hennessy ਉਹਨਾਂ ਆਰਕੀਟੈਕਟਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹਨ ਜਿਨ੍ਹਾਂ ਨੇ ਸਭ ਤੋਂ ਸਪਸ਼ਟ ਢੰਗ ਨਾਲ ਦੱਸਿਆ ਕਿ ਕੰਪਿਊਟਰ ਤੇਜ਼ ਕਿਉਂ ਹੁੰਦੇ ਹਨ — ਅਤੇ ਕਈ ਵਾਰੀ ਇਹ ਤਰੱਕੀ ਕਿਉਂ ਰੁਕ ਜਾਂਦੀ ਹੈ। ਪ੍ਰਭਾਵਸ਼ালী ਪ੍ਰੋਸੈਸਰ ਬਣਾਉਣ ਅਤੇ RISC ਵਿਚਾਰ ਲੋਕ-ਪ੍ਰਚਲਿਤ ਕਰਨ ਦੇ ਇਲਾਵਾ, ਉਹਨਾਂ ਨੇ ਪ੍ਰਣਾਲੀ ਨਿਰਮਾਤਿਆਂ ਨੂੰ ਪ੍ਰਦਰਸ਼ਨ ਫੈਸਲਿਆਂ ਲਈ ਇੱਕ ਪ੍ਰਯੋਗਿਕ ਭਾਸ਼ਾ ਦਿੱਤੀ: ਕਿਸ ਨੂੰ ਓਪਟੀਮਾਈਜ਼ ਕਰਨਾ ਹੈ, ਕਿਸ ਨੂੰ ਨਹੀਂ, ਅਤੇ ਫਰਕ ਕਿਵੇਂ ਪਛਾਣਨਾ ਹੈ।

ਜਦੋਂ ਲੋਕ “ਪਰਫਾਰਮੈਂਸ ਸਕੇਲਿੰਗ” ਕਹਿੰਦੇ ਹਨ, ਉਹ ਅਕਸਰ ਮਤਲਬ ਲੈਂਦੇ ਹਨ “ਮੇਰਾ ਪ੍ਰੋਗਰਾਮ ਤੇਜ਼ ਚੱਲਦਾ ਹੈ।” ਅਸਲ ਪ੍ਰਣਾਲੀਆਂ ਵਿੱਚ, ਸਕੇਲਿੰਗ ਇੱਕ ਤਿੰਨ-ਕੋਣੀ ਸਮਝੌਤਾ ਹੈ: ਗਤੀ, ਲਾਗਤ, ਅਤੇ ਪਾਵਰ/ਉਰਜਾ। ਇੱਕ ਬਦਲਾਅ ਜੋ ਕਿਸੇ ਵਰਕਲੋਡ ਨੂੰ 20% ਤੇਜ਼ ਕਰ ਦਿੰਦਾ ਹੈ, ਚਿਪ ਨੂੰ ਮਹਿੰਗਾ ਕਰ ਸਕਦਾ ਹੈ, ਸਰਵਰ ਨੂੰ ਠੰਡਾ ਕਰਨਾ ਮੁਸ਼ਕਲ ਕਰ ਸਕਦਾ ਹੈ, ਜਾਂ ਬੈਟਰੀ ਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਘੱਟ ਕਰ ਸਕਦਾ ਹੈ। Hennessy ਦੀ ਰੂਪਰੇਖਾ ਇਸ ਲਈ ਜ਼ਰੂਰੀ ਹੈ ਕਿਉਂਕਿ ਇਹ ਉਹਨਾਂ ਸੀਮਾਵਾਂ ਨੂੰ ਇਕ ਸਧਾਰਨ ਇੰਜੀਨੀਅਰਿੰਗ ਇਨਪੁੱਟ ਸਮਝਦੀ ਹੈ — ਨਾ ਕਿ ਕੋਈ ਅਣਚਾਹੀ ਹੈਰਾਨੀ।

ਉਹ ਤਿੰਨ ਥੀਮਾਂ ਜਿਹਨਾਂ ਨੂੰ ਅਸੀਂ ਪੂਰੇ ਲੇਖ ਵਿੱਚ ਵਰਤਾਂਗੇ

ਪਹਿਲੀ ਹੈ ਪੈਰਾਲਲਿਜ਼ਮ: ਇੱਕੋ ਸਮੇਂ ਹੋਰ ਕੰਮ ਕਰਨਾ। ਇਹ ਇੱਕ ਕੋਰ ਦੇ ਅੰਦਰ (ਇੰਸਟਰਕਸ਼ਨ-ਲੇਵਲ ਤਰਕੀਬਾਂ), ਕੋਰਾਂ ਦੇ ਪਾਰ (ਥ੍ਰੈਡ), ਅਤੇ ਪੂਰੇ ਮਸ਼ੀਨਾਂ ਦੇ ਪਾਰ ਉੱਪਸਥਿਤ ਹੁੰਦਾ ਹੈ।

ਦੂਜੀ ਹੈ ਸਪੈਸ਼ਲਾਈਜ਼ੇਸ਼ਨ: ਕੰਮ ਲਈ ਠੀਕ ਟੂਲ ਵਰਤਣਾ। GPUs, ਵੀਡੀਓ ਐਨਕੋਡਰ, ਅਤੇ ML ਐਕਸੇਲੇਰੇਟਰ ਇਸ ਲਈ ਹਨ ਕਿਉਂਕਿ ਜਨਰਲ-ਪਪਰਪਜ਼ CPUs ਸਾਰਾ ਕੰਮ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਨਹੀਂ ਕਰ ਸਕਦੇ।

ਤੀਜੀ ਹੈ ਟਰੇਡਆਫ਼ਸ: ਹਰ “ਜਿੱਤ” ਦੀ ਕੀਮਤ ਹੁੰਦੀ ਹੈ। ਮੁੱਖ ਗੱਲ ਇਹ ਸਮਝਣਾ ਹੈ ਕਿ ਸੀਮਾ ਕਿੱਥੇ ਹੈ — ਕੰਪਿਊਟ, ਮੇਮੋਰੀ, ਕਮਿਊਨੀਕੇਸ਼ਨ, ਜਾਂ ਉਰਜਾ।

ਕੀ ਉਮੀਦ ਰੱਖੋ

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

“ਫ੍ਰੀ” ਤੇਜ਼ੀ ਤੋਂ ਅਸਲੀ ਸੀਮਾਵਾਂ ਤੱਕ

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

“ਮੁਫ਼ਤ ਪਰਫਾਰਮੈਂਸ” ਦਾ ਯੁੱਗ

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

“ਪਾਵਰ ਵਾਲ” ਨੇ ਕਿਉਂ ਨਿਯਮ ਬਦਲੇ

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

ਇੱਕ ਸਾਰਲAnalogੀ: ਕਾਰ ਇੰਜਣ vs. ਹੀਟ ਅਤੇ ਫ਼ਿਊਲ

ਇੱਕ ਕਾਰ ਇੰਜਣ ਬਾਰੇ ਸੋਚੋ। ਤੁਸੀਂ ਅਕਸਰ ਅੱਗੇ ਵਧ ਸਕਦੇ ਹੋ ਜੇ RPM ਵਧਾਓ—ਜਦ ਤੱਕ ਤੁਸੀਂ ਸੀਮਾਵਾਂ ਨੂੰ ਨਹੀਂ ਛੂਹਦੇ: ਫਿਊਲ ਖਪਤ ਵਧਦੀ ਹੈ, ਹਿੱਸੇ ਓਵਰਹੀਟ ਹੋ ਜਾਂਦੇ ਹਨ, ਅਤੇ ਪ੍ਰਣਾਲੀ ਅਸੁਰੱਖਿਅਤ ਬਣ ਜਾਂਦੀ ਹੈ। CPUs ਨੇ ਵੀ ਇਸੇ ਤਰ੍ਹਾਂ ਦੀ ਸੀਮਾ ਨੂੰ ਛੁਹਿਆ: “RPM” (ਕਲਾਕ ਸਪੀਡ) ਵਧਾਉਣਾ ਬਹੁਤ ਜ਼ਿਆਦਾ ਊਰਜਾ ਲੈਂਦਾ ਹੈ ਅਤੇ ਹੋਰ ਗਰਮੀ ਪੈਦਾ ਕਰਦਾ ਹੈ।

ਮੁਫ਼ਤ ਤੇਜ਼ੀ ਤੋਂ ਸਮਝਦਾਰ ਡਿਜ਼ਾਈਨ ਤੱਕ

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

ਇੰਸਟਰਕਸ਼ਨ-ਲੇਵਲ ਪੈਰਾਲਲਿਜ਼ਮ: ਲਾਭ ਅਤੇ ਘਟਦੇ ਫਾਇਦੇ

Instruction-Level Parallelism (ILP) ਦਾ ਮਤਲਬ ਹੈ ਇੱਕ ਇਕੱਲੇ CPU ਕੋਰ ਦੇ ਅੰਦਰ ਹੀ "ਛੋਟੇ-ਛੋਟੇ ਕਦਮ ਇੱਕੱਠੇ ਕਰਨਾ।" ਭਾਵੇਂ ਤੁਹਾਡਾ ਪ੍ਰੋਗਰਾਮ “ਸਿੰਗਲ-ਥ੍ਰੈਡਿਡ” ਹੋਵੇ, ਪ੍ਰੋਸੈਸਰ ਅਕਸਰ ਕੰਮ ਨੂੰ ਓਵਰਲੈਪ ਕਰ ਸਕਦਾ ਹੈ: ਜਦੋਂ ਇੱਕ ਇੰਸਟਰਕਸ਼ਨ ਕਿਸੇ ਚੀਜ਼ ਦੀ ਉਡੀਕ ਕਰ ਰਿਹਾ ਹੋਵੇ, ਦੂਜਾ ਸ਼ੁਰੂ ਹੋ ਸਕਦਾ ਹੈ — ਜੇ ਉਹ ਇਕੱਲੇ-ਨਿਰਭਰ ਨਹੀਂ ਹਨ।

ਪਾਈਪਲਾਈਨਿੰਗ: ਅਸੈਂਬਲੀ ਲਾਈਨ ਪ੍ਰਭਾਵ

ILP ਦੀ ਇੱਕ ਸਧਾਰਨ ਤਸਵੀਰ ਹੈ ਪਾਈਪਲਾਈਨਿੰਗ। ਇੱਕ ਕੰਧੀ ਲਾਈਨ ਬਾਰੇ ਸੋਚੋ: ਇੱਕ ਚਰਨ ਇੰਸਟਰਕਸ਼ਨ ਫੈਚ ਕਰਦਾ ਹੈ, ਦੂਜਾ ਡੀਕੋਡ ਕਰਦਾ ਹੈ, ਤੀਜਾ ਐਕਜ਼ਿਕਿਊਟ ਕਰਦਾ ਹੈ, ਅਤੇ ਚੌਥਾ ਨਤੀਜਾ ਲਿਖਦਾ ਹੈ। ਜਦੋਂ ਪਾਈਪਲਾਈਨ ਭਰ ਜਾਂਦਾ ਹੈ, CPU ਲਗਭਗ ਇੱਕ ਸਾਇਕਲ ਵਿੱਚ ਇੱਕ ਇੰਸਟਰਕਸ਼ਨ ਪੂਰਾ ਕਰ ਸਕਦਾ ਹੈ, ਭਾਵੇਂ ਹਰ ਇੰਸਟਰਕਸ਼ਨ ਨੂੰ ਅਜੇ ਵੀ ਕਈ ਚਰਨਾਂ ਵਿੱਚ ਲੰਘਣਾ ਪੈਂਦਾ ਹੈ।

ਪਾਈਪਲਾਈਨਿੰਗ ਨੇ ਸਾਲਾਂ ਤੱਕ ਪਰਫਾਰਮੈਂਸ ਸੁਧਾਰ ਵਿੱਚ ਯੋਗਦਾਨ ਦਿੱਤਾ ਕਿਉਂਕਿ ਇਹ throughput ਵਧਾਉਂਦਾ ਸੀ ਬਿਨਾਂ ਵਿਕਾਸਕਰਤਾਵਾਂ ਨੂੰ ਸਭ ਕੁਝ ਮੁੜ ਲਿਖਣ ਦੀ ਲੋੜ ਪਏ।

ਬਰਾਂਚ ਪ预测ਣ: ਪਾਈਪਲਾਈਨ ਨੂੰ ਖੁਰਾਕ ਰੱਖਣਾ

ਅਸਲ ਪ੍ਰੋਗਰਾਮ ਸਿੱਧੀ ਲਕੀਰ ਵਿੱਚ ਨਹੀਂ ਚਲਦੇ। ਉਹ ਬਰਾਂਚ (‘ਜੇ ਇਹ, ਤਾਂ ਉਹ’) ਮਾਰਦੇ ਹਨ, ਅਤੇ CPU ਨੂੰ ਅਗਲਾ ਕੀ ਫੈਚ ਕਰਨਾ ਹੈ ਫੈਸਲਾ ਕਰਨਾ ਪੈਂਦਾ ਹੈ। ਜੇ ਇਹ ਪਤਾ ਕਰਨ ਲਈ ਰੁਕੇ, ਤਾਂ ਪਾਈਪਲਾਈਨ ਸਟਾਲ ਹੋ ਸਕਦੀ ਹੈ।

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

ਲਾਗਤ: ਜਟਿਲਤਾ, ਪਾਵਰ, ਅਤੇ ਘਟਦੇ ਨਤੀਜੇ

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

ਇਹ Hennessy ਦਾ ਇਕ ਮੁੜ-ਮੁੜ ਆਉਣ ਵਾਲਾ ਪਾਠ ਹੈ: ILP ਕੀਮਤੀ ਹੈ, ਪਰ ਇਸ ਨੂੰ ਅਮਲਿਕ ਸਿਫ਼ਤਾਂ ਹਨ — ਇਸ ਲਈ ਲੰਮੇ ਸਮੇਂ ਲਈ ਪਰਫਾਰਮੈਂਸ ਸਕੇਲਿੰਗ ਨੂੰ ਹੋਰ ਰਾਹਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਨਾ ਕਿ ਸਿਰਫ “ਅਧਿਕ ਚਤੁਰ” ਸਿੰਗਲ-ਕੋਰ ਨਿਰਵਹ।

Amdahl’s Law: ਵੱਡੇ ਫੈਸਲਿਆਂ ਦੇ ਪਿੱਛੇ ਸਧਾਰਨ ਗਣਿਤ

Amdahl’s Law ਯਾਦ ਦਿਲਾਉਂਦੀ ਹੈ ਕਿ ਕੰਮ ਦੇ ਕਿਸੇ ਹਿੱਸੇ ਨੂੰ ਤੇਜ਼ ਕਰਨ ਨਾਲ ਪੂਰੇ ਕੰਮ ਨੂੰ ਉਸ ਹੱਦ ਤੋਂ ਵੱਧ ਤੇਜ਼ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਜੋ ਬਾਕੀ ਦੇ ਸਲੋ ਹਿੱਸੇ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਤੁਹਾਨੂੰ ਭਾਰੀ ਗਣਿਤ ਦੀ ਲੋੜ ਨਹੀਂ — ਸਿਰਫ ਇਹ ਦੇਖਣਾ ਹੈ ਕਿ ਕੀ ਪੈਰਾਲਲ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ।

ਇੱਕ ਰੋਜ਼ਾਨਾ ਉਦਾਹਰਨ

ਇੱਕ ਗ੍ਰੋਸਰੀ ਸਟੋਰ ਵਿੱਚ ਇੱਕ ਗਾਹਕ ਅਤੇ ਚੈੱਕਆਉਟ ਪ੍ਰਕਿਰਿਆ ਦੀ ਕਲਪਨਾ ਕਰੋ:

• ਆਈਟਮ ਸਕੈਨ ਕਰਨਾ ਕਈ ਰਜਿਸਟਰਾਂ ਵਿੱਚ ਵੰਡਿਆ ਜਾ ਸਕਦਾ ਹੈ (ਪੈਰਾਲਲ ਕੰਮ)।
• ਭੁਗਤਾਨ (ਇੱਕ ਕਾਰਡ, ਇੱਕ ਰਸੀਦ) ਫਿਰ ਵੀ ਇੱਕ ਹੀ ਕਦਮ ਹੈ (ਸਿਰਿਯਲ ਕੰਮ)।

ਜੇ ਭੁਗਤਾਨ ਹਮੇਸ਼ਾ ਕੁੱਲ ਸਮੇਂ ਦਾ 10% ਲੈਂਦਾ ਹੈ, ਤਾਂ ਚਾਹੇ ਤੁਸੀਂ ਸਕੈਨਿੰਗ ਨੂੰ "ਤੁਰੰਤ" ਬਣਾ ਦਿਓ, ਕੁੱਲ ਤੌਰ ਤੇ ਤੁਸੀਂ ਥੋੜ੍ਹਾ ਜਿਹਾ ਹੀ ਤੇਜ਼ ਹੋ ਸਕਦੇ—ਲਗਭਗ 10×। ਸਿਰਿਯਲ ਹਿੱਸਾ ਛੱਤ ਬਣ ਜਾਂਦਾ ਹੈ।

ਖਾਣ-ਪਕਵਾਨ ਵੀ ਇਹੀ ਪੈਟਰਨ ਦਿਖਾਉਂਦਾ ਹੈ: ਤੁਸੀਂ ਸਬਜ਼ੀਆਂ ਕਟ ਸਕਦੇ ਹੋ ਜਦੋਂ ਪਾਣੀ ਗਰਮ ਹੋ ਰਿਹਾ (ਪੈਰਾਲਲ), ਪਰ ਤੁਸੀਂ ਉਹਨਾਂ ਨੂੰ ਓਵਨ ਵਿੱਚ 30 ਮਿੰਟ ਲਈ ਰੱਖਣ ਵਾਲੇ ਬੇਕਿੰਗ ਨੂੰ ਪੈਰਾਲਲ ਨਹੀਂ ਕਰ ਸਕਦੇ।

ਕਿਉਂ ਇੱਕ ਛੋਟਾ ਸਿਰੀਅਲ ਹਿੱਸਾ ਡੋਮੀਨੇਟ ਕਰਦਾ ਹੈ

ਮੁੱਖ ਤਰਕੀਬ ਇਹ ਹੈ ਕਿ ਅੰਤਿਮ ਕੁਝ ਪ੍ਰਤੀਸ਼ਤ ਸਿਰੀਅਲ ਕੰਮ ਸਾਰੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸੀਮਿਤ ਕਰ ਦਿੰਦੇ ਹਨ। ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਜੋ “99% ਪੈਰਾਲਲ” ਹੈ ਸੋਹਣਾ ਲੱਗਦਾ ਹੈ—ਜਦ ਤੱਕ ਤੁਸੀਂ ਇਸਨੂੰ ਬਹੁਤ ਸਾਰੀਆਂ ਕੋਰਾਂ 'ਤੇ स्कੇਲ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਨਹੀਂ ਕਰਦੇ ਅਤੇ ਪਤਾ ਲਗਦਾ ਹੈ ਕਿ 1% ਸਿਰੀਅਲ ਹਿੱਸਾ ਲੰਬਾ ਖੜਾ ਰਹਿ ਗਿਆ ਹੈ।

ਇਹ ਆਰਕੀਟੈਕਚਰ ਫੈਸਲਿਆਂ ਨੂੰ ਕਿਉਂ ਰੂਪ ਦਿੰਦੀ ਹੈ

Amdahl’s Law ਇਸ ਲਈ ਹੈ ਕਿ “ਸਿਰਫ ਕੋਰ ਵਧਾਓ” ਅਕਸਰ ਨਿਰਾਸ਼ਾ ਕਰਦਾ ਹੈ। ਹੋਰ ਕੋਰਾਂ ਫਾਇਦਾ ਦਿੰਦੇ ਹਨ ਸਿਰਫ ਜਦੋਂ ਕਾਫ਼ੀ ਪੈਰਾਲਲ ਕੰਮ ਹੋਵੇ ਅਤੇ ਸਿਰੀਅਲ ਬੋਤਲਨੈਕ (ਸਿੰਕਰੋਨਾਈਜ਼ੇਸ਼ਨ, I/O, ਇੱਕ-ਥ੍ਰੈਡ ਫੇਜ਼, ਮੇਮੋਰੀ ਸਟਾਲ) ਛੋਟੇ ਰੱਖੇ ਜਾ ਸਕਦੇ ਹੋਣ।

ਇਹ ਹੀ ਸਮਝਾਉਂਦਾ ਹੈ ਕਿ ਐਕਸੇਲੇਰੇਟਰ ਮੁਸ਼ਕਲ ਕਿਉਂ ਹੋ ਸਕਦੇ ਹਨ: ਜੇ GPU ਇੱਕ kernel ਨੂੰ ਤੇਜ਼ ਕਰਦਾ ਹੈ, ਪਰ ਪਾਈਪਲਾਈਨ ਬਾਕੀ ਸਿਰੀਅਲ ਹੀ ਰਹਿੰਦੀ ਹੈ, ਤਾਂ ਕੁੱਲ ਨਤੀਜਾ ਮਿਆਰੀ ਰਹਿ ਸਕਦਾ ਹੈ।

ਨਿਯਮ ਆਮ ਤੌਰ 'ਤੇ

ਪੈਰਾਲਲਿਜ਼ਮ ਵਿੱਚ ਨਿਵੇਸ਼ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਪੁੱਛੋ: ਕੀ ਫ਼ਰਕ ਅਸਲ ਵਿੱਚ ਪੈਰਾਲਲ ਹੈ, ਤੇ ਕੀ ਕੁਝ ਸਿਰੀਅਲ ਹੀ ਰਹਿੰਦਾ ਹੈ? ਫਿਰ ਉਹਥੇ ਸਮਾਂ ਲਗਾਓ ਜਿੱਥੇ ਵਕਤ ਅਸਲ ਵਿੱਚ ਲੱਗ ਰਿਹਾ ਹੈ—ਅਕਸਰ “ਬੋoring” ਸਿਰੀਅਲ ਰਸਤਾ—ਕਿਉਂਕਿ ਉਹੀ ਸੀਮਾ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ।

ਥ੍ਰੈਡ-ਲੇਵਲ ਪੈਰਾਲਲਿਜ਼ਮ: ਮਲਟੀਕੋਰ ਬਦਲਾਅ

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

ਇੱਕ ਕੰਮ ਤੇਜ਼ vs. ਜ਼ਿਆਦਾ ਕੰਮ

ਮਲਟੀਕੋਰ ਦੋ ਤਰੀਕਿਆਂ ਨਾਲ ਮਦਦ ਕਰਦਾ ਹੈ:

• ਇੱਕ ਨੌਕਰੀ ਤੇਜ਼ ਬਣਾਓ: ਇਸਨੂੰ ਪੈਰਾਲਲ ਟੁਕੜਿਆਂ ਵਿੱਚ ਵੰਡ ਕੇ (ਇੱਕ ਪ੍ਰੋਗਰਾਮ, ਬਹੁਤ ਸਾਰੇ ਥ੍ਰੈਡ)।
• ਜ਼ਿਆਦਾ ਨੌਕਰੀਆਂ ਇਕੱਠੇ ਚਲਾਓ: ਬਹੁਤ ਸਾਰੇ ਪ੍ਰੋਗਰਾਮ ਇਕੱਠੇ (ਹਰ ਇੱਕ ਲਈ ਥ੍ਰੈਡ ਜਾਂ ਪ੍ਰੋਸੈਸ) — ਇਸ ਨਾਲ ਸੋਝੀਅਤਾ ਅਤੇ ਥਰਪੁਟ੍ਰੂ ਵਧਦਾ ਹੈ ਭਾਵੇਂ ਕੋਈ ਇਕੱਲਾ ਨੌਕਰੀ ਤੇਜ਼ ਨਾ ਹੋਵੇ।

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

ਸੋਫਟਵੇਅਰ ਨੂੰ ਲਾਭ ਲੈਣ ਲਈ ਕੀ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ

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

ਆਮ ਪ੍ਰਯੋਗਿਕ ਚਲਨ ਵਿੱਚ ਲੂਪਾਂ ਦੀ ਪੈਰਾਲਲਾਈਜ਼ੇਸ਼ਨ, ਅਜ਼ਾਦ ਚਰਣਾਂ ਨੂੰ ਵੱਖਰਾ ਕਰਨਾ (ਜਿਵੇਂ decode → process → encode), ਜਾਂ ਬਹੁਤ ਸਾਰੀਆਂ ਬੇਨਤੀਆਂ/ਈਵੈਂਟਾਂ ਨੂੰ ਇਕੱਠੇ ਸੰਭਾਲਣਾ ਸ਼ਾਮਲ ਹੈ।

ਘਟਾਓ: ਯੋਜਨਾ ਅਤੇ ਸਾਂਝੇ ਸਰੋਤ

ਮਲਟੀਕੋਰ ਸਕੇਲਿੰਗ ਅਕਸਰ ਓਵਰਹੈੱਡ 'ਤੇ ਰੁਕਦੀ ਹੈ:

• ਸੰਯੋਜ਼ਨ ਲਾਗਤਾਂ: ਲਾਕ, ਕੰਟੈਨਸ਼ਨ, ਸ਼ੈਡਿਊਲਿੰਗ, ਅਤੇ ਸਿੰਕਰੋਨਾਈਜ਼ੇਸ਼ਨ ਵਾਧੇ ਹੋਏ ਕੋਰਾਂ ਦੇ ਫਾਇਦੇ ਨੂੰ ਮਿਟਾ ਸਕਦੇ ਹਨ।
• ਸਾਂਝੇ ਸਰੋਤ: ਕਈ ਕੋਰ caches, ਮੇਮੋਰੀ ਬੈਂਡਵਿਡਥ, ਅਤੇ I/O ਲਈ ਮੁਕਾਬਲਾ ਕਰਦੇ ਹਨ; ਕੋਰ ਵਧਾਉਣਾ ਮੇਮੋਰੀ ਦੀ ਗਤੀ ਨੂੰ ਆਪਣੇ ਆਪ ਨਹੀਂ ਵਧਾਉਂਦਾ।

Hennessy ਦਾ ਵੱਡਾ ਸੁਨੇਹਾ ਇਥੇ ਵੀ लागू ਹੋਦਾ: ਪੈਰਾਲਲਿਜ਼ਮ ਸ਼ਕਤੀਸ਼ਾਲੀ ਹੈ, ਪਰ ਅਸਲ ਤੇਜ਼ੀ ਧਿਆਨਪੂਰਵਕ ਸਿਸਟਮ ਡਿਜ਼ਾਈਨ ਅਤੇ ਈਮਾਨਦਾਰ ਮਾਪ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ—ਸਿਰਫ਼ ਜ਼ਿਆਦਾ ਕੋਰ ਜੋੜ ਕੇ ਨਹੀਂ।

ਮੇਮੋਰੀ ਅਤੇ ਛੁਪਿਆ ਹੋਇਆ ਬੋਤਲਨੈਕ

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

ਲੈਟੈਂਸੀ: ਡਾਟਾ ਦੀ ਉਡੀਕ ਦੀ ਲਾਗਤ

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

ਕੈਸ਼: ਨਜ਼ਦੀਕੀ ਸ਼ੈਲ੍ਵਜ਼ ਜਿੱਥੇ ਅਕਸਰ ਵਰਤੇ ਚੀਜ਼ਾਂ ਰੱਖੀਆਂ ਜਾਂਦੀਆਂ ਹਨ

ਉਡੀਕ ਘਟਾਉਣ ਲਈ, ਕੰਪਿਊਟਰ ਕੈਸ਼ ਵਰਤਦੇ ਹਨ, ਛੋਟੀ ਅਤੇ ਤੇਜ਼ ਮੈਮੋਰੀ ਏਰੀਆ ਜੋ CPU ਦੇ ਨੇੜੇ ਹੁੰਦੀ ਹੈ—ਇਕ ਨਜ਼ਦੀਕੀ ਸ਼ੈਲਫ ਜਿਸ 'ਤੇ ਤੁਸੀਂ ਸਭ ਤੋਂ ਜ਼ਿਆਦਾ ਵਰਤੇ ਜਾਣ ਵਾਲੇ ਪਾਰਟ ਰੱਖਦੇ ਹੋ। ਜਦੋਂ ਲੋੜੀਂਦਾ ਡਾਟਾ ਪਹਿਲਾਂ ਹੀ ਸ਼ੈਲਫ 'ਤੇ ਹੁੰਦਾ ਹੈ (ਇੱਕ “cache hit”), ਕੰਮ ਸੁਚਾਰੂ ਚੱਲਦਾ ਰਹਿੰਦਾ ਹੈ। ਜਦੋਂ ਨਹੀਂ (ਇੱਕ “miss”), CPU ਨੂੰ ਦੂਰੋਂ ਲਿਆਉਣਾ ਪੈਂਦਾ ਹੈ ਅਤੇ ਪੂਰੀ ਲੈਟੈਂਸੀ ਭੁਗਤਣੀ ਪੈਂਦੀ ਹੈ।

ਬੈਂਡਵਿਡਥ ਬਨਾਮ ਲੈਟੈਂਸੀ (ਅਤੇ ਦੋਹਾਂ ਦੀ ਲੋੜ ਕਿਉਂ)

ਲੈਟੈਂਸੀ ਹੈ “ਪਹਿਲੀ ਆਈਟਮ ਆਉਣ ਵਿੱਚ ਕਿੰਨਾ ਸਮਾਂ”। ਬੈਂਡਵਿਡਥ ਹੈ “ਫ਼ਿਲਹਾਲ ਇੱਕ ਸਕਿੰਟ ਵਿੱਚ ਕਿੰਨੇ ਆਈਟਮ ਆ ਸਕਦੇ ਹਨ।” ਤੁਹਾਡੇ ਕੋਲ ਉੱਚ ਬੈਂਡਵਿਡਥ ਹੋ ਸਕਦੀ ਹੈ (ਵਿਆਪਕ ਹਾਈਵੇ), ਪਰ ਫਿਰ ਵੀ ਉੱਚ ਲੈਟੈਂਸੀ ਹੋ ਸਕਦੀ ਹੈ (ਲੰਬੀ ਦੂਰੀ)। ਕੁਝ ਵਰਕਲੋਡ ਬਹੁਤ ਸਾਰਾ ਡਾਟਾ ਸਟਰਿਮ ਕਰਦੇ ਹਨ (ਬੈਂਡਵਿਡਥ-ਬਾਊਂਡ), ਜਦਕਿ ਦੂਜੇ ਛੋਟੇ, ਵੱਖਰੇ ਹਿੱਸਿਆਂ ਦੀ ਨਿਰੰਤਰ ਲੋੜ ਕਰਦੇ ਹਨ (ਲੈਟੈਂਸੀ-ਬਾਊਂਡ)। ਕਿਸੇ ਵੀ ਮਾਮਲੇ ਵਿੱਚ ਸਿਸਟਮ ਧੀਮਾ ਮਹਿਸੂਸ ਹੋ ਸਕਦਾ ਹੈ।

ਮੇਮੋਰੀ ਵਾਲ

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

ਪਾਵਰ ਇੱਕ ਪ੍ਰਾਥਮਿਕ ਸੀਮਾ ਹੈ

ਕਾਫ਼ੀ ਸਮੇਂ ਲਈ, “ਤੇਜ਼” ਦਾ ਮਤਲਬ ਆਮ ਤੌਰ 'ਤੇ ਘੜੀ ਉੱਚੀ ਰੱਖਨਾ ਸੀ। ਇਹ ਸੋਚ ਤਦ ਤੱਤ ਹੋ ਜਾਂਦੀ ਹੈ ਜਦ ਪਾਵਰ ਨੂੰ ਇੱਕ ਕਠੋਰ ਬਜਟ ਮੰਨਿਆ ਜਾਵੇ ਨਾ ਕਿ ਇੱਕ ਬਾਅਦ ਦੀ ਚਿੰਤਾ। ਹਰ ਇਕ ਵਾਧੂ ਵਾਟ ਹੀਟ ਬਣ ਜਾਂਦੀ ਹੈ ਜਿਸਨੂੰ ਤੁਹਾਨੂੰ ਹਟਾਉਣਾ ਪੈਂਦਾ ਹੈ, ਬੈਟਰੀ ਖਤਮ ਹੁੰਦੀ ਹੈ, ਜਾਂ ਬਿਜਲੀ ਦਾ ਬਿਲ ਵਧਦਾ ਹੈ। ਪਰਫਾਰਮੈਂਸ ਕਰੋ — ਪਰ ਇਹ ਪ੍ਰਤੀ-ਵਾਟ ਹੈ ਜੋ ਅੰਤ ਵਿੱਚ ਨਿਰਧਾਰਿਤ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਵਰਤਿਆ ਜਾਵੇਗਾ।

ਮੁੱਖ ਟਰੇਡਆਫ਼: ਗਤੀ ਵਿਰੁੱਧ ਊਰਜਾ

ਪਾਵਰ ਸਿਰਫ ਇੱਕ ਤਕਨੀਕੀ ਵਿਸ਼ਾ ਨਹੀਂ; ਇਹ ਇੱਕ ਉਤਪਾਦ ਸੀਮਾ ਹੈ। ਇੱਕ ਲੈਪਟੌਪ ਜੋ ਬੈਂਚਮਾਰਕ ਵਿੱਚ ਚੰਗਾ ਹੈ ਪਰ ਦੋ ਮਿੰਟ ਬਾਅਦ throttling ਕਰਦਾ ਹੈ, ਓਹੀ ਧੀਮਾ ਮਹਿਸੂਸ ਹੁੰਦਾ ਹੈ। ਇੱਕ ਫ਼ੋਨ ਜੋ ਪੇਜ਼ ਉਦੋਂ ਤੁਰੰਤ ਰੇਂਡਰ ਕਰ ਦਿੰਦਾ ਹੈ ਪਰ 20% ਬੈਟਰੀ ਖਾ ਜਾਂਦਾ ਹੈ, ਕਾਬਿਲ-قبول ਨਹੀਂ। ਵੀ ਸਰਵਰਾਂ ਵਿੱਚ, ਤੁਹਾਡੇ ਕੋਲ ਖਾਲੀ ਕਮਪਿਊਟ ਸਮਰੱਥਾ ਹੋ ਸਕਦੀ ਹੈ ਪਰ ਕੋਈ ਫਜ਼ੂਲ ਪਾਵਰ ਜਾਂ ਕੁਲਿੰਗ ਹੈਡਰੂਮ ਨਹੀਂ।

ਕਿਉਂ ਫ੍ਰਿਕਵੈਂਸੀ ਮਹਿੰਗੀ ਪੈਂਦੀ ਹੈ

ਫ੍ਰਿਕਵੈਂਸੀ ਵਧਾਉਣਾ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਮਹਿੰਗਾ ਹੁੰਦਾ ਹੈ ਕਿਉਂਕਿ ਜਿਵੇਂ ਤੁਸੀਂ ਵੋਲਟੇਜ ਅਤੇ switching activity ਵਧਾਉਂਦੇ ਹੋ, ਪਾਵਰ ਤੇਜ਼ੀ ਨਾਲ ਵਧਦਾ ਹੈ। ਸਧਾਰਣ ਸ਼ਬਦਾਂ ਵਿੱਚ, ਡਾਇਨੈਮਿਕ ਪਾਵਰ ਇਸ ਤਰ੍ਹਾਂ ਤਕਰੀਬਨ ਚੱਲਦਾ ਹੈ:

• ਵੱਧ switching ਕੰਮ (ਉੱਚ ਫ੍ਰਿਕਵੈਂਸੀ) ਦਾ ਮਤਲਬ ਇੱਕ ਸਕਿੰਟ ਵਿੱਚ ਵੱਧ ਊਰਜਾ ਹੈ
• ਵਧੇਰੇ ਵੋਲਟੇਜ (ਅਕਸਰ ਉੱਚ clocks ਲਈ ਜ਼ਰੂਰੀ) ਲਾਗਤ ਨੂੰ ਗੁਣਾ ਕਰ ਦਿੰਦਾ ਹੈ

ਇਸ ਲਈ ਆਖ਼ਰੀ 10–20% ਕਲਾਕ ਸਪੀਡ ਵੱਧ ਵਾਟ ਦੀ ਮੰਗ ਕਰ ਸਕਦੀ ਹੈ—ਜੋ ਤਾਪਮਾਨ ਸੀਮਾਵਾਂ ਅਤੇ throttling ਵੱਲ ਲੈ ਜਾਂਦੀ ਹੈ ਬਜਾਏ ਲੰਬੀ ਸਮੇਂ ਲਈ ਉਤਪਾਦਕ ਤੀਜ਼ੀ ਦੇ।

ਪ੍ਰੈਕਟਿਕਲ ਨਤੀਜੇ: ਮੋਬਾਈਲ, ਡੇਟਾ ਸੈਂਟਰ, ਕਲਾਉਡ ਖ਼ਰਚੇ

ਇਸੇ ਲਈ ਆਧੁਨਿਕ ਡਿਜ਼ਾਈਨ ਕੁਸ਼ਲਤਾ 'ਤੇ ਜ਼ੋਰ ਦਿੰਦੇ ਹਨ: ਵਿਆਪਕ ਪੈਰਾਲਲਿਜ਼ਮ, ਸਮਾਰਟ ਪਾਵਰ ਮੈਨੇਜਮੈਂਟ, ਅਤੇ “ਕਾਫ਼ੀ ਚੰਗੇ” ਕਲਾਕ ਜੋ ਬਿਹਤਰ ਮਾਈਕ੍ਰੋਆਰਕੀਟੈਕਚਰ ਨਾਲ ਜੋੜੇ ਹੋਣ। ਡੇਟਾ ਸੈਂਟਰ ਵਿੱਚ, ਪਾਵਰ ਇੱਕ ਲਾਈਨ ਆਈਟਮ ਹੈ ਜੋ ਸਮੇਂ ਦੇ ਨਾਲ-ਨਾਲ ਹਾਰਡਵੇਅਰ ਲਾਗਤ ਨਾਲ ਟਕਰਾਂਦਾ ਹੈ। ਕਲਾਉਡ ਵਿੱਚ, ਅਣਕਾਰਗਰ ਕੋਡ ਸਿੱਧਾ ਤੁਹਾਡੇ ਬਿੱਲ ਨੂੰ ਵਧਾ ਸਕਦਾ ਹੈ—ਕਿਉਂਕਿ ਤੁਸੀਂ ਸਮੇਂ, ਕੋਰਾਂ, ਅਤੇ (ਅਕਸਰ ਪਰੋਕਸੀ ਰੂਪ ਵਿੱਚ) ਊਰਜਾ ਲਈ ਭੁਗਤਾਨ ਕਰਦੇ ਹੋ।

ਹਾਰਡਵੇਅਰ–ਸੌਫਟਵੇਅਰ ਕੋ-ਡਿਜ਼ਾਈਨ ਇੱਕ ਰਣਨੀਤੀ ਵਜੋਂ

Hennessy ਦਾ ਮੁੜ-ਮੁੜ ਆਉਣ ਵਾਲਾ ਧਿਆਨ ਸਧਾਰਨ ਹੈ: ਪਰਫਾਰਮੈਂਸ ਸਕੇਲਿੰਗ ਸਿਰਫ ਹਾਰਡਵੇਅਰ ਦੀ ਸਮੱਸਿਆ ਨਹੀਂ ਹੈ ਅਤੇ ਨਾ ਹੀ ਸਿਰਫ ਸੋਫਟਵੇਅਰ ਦੀ। hardware–software co-design ਦਾ ਮਤਲਬ ਹੈ ਕਿ CPU ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ, ਕੰਪਾਇਲਰ, ਰਨਟਾਈਮ, ਅਤੇ الگੋਰਿਦਮਾਂ ਨੂੰ ਅਸਲ ਵਰਕਲੋਡਾਂ ਦੇ ਅਨੁਸਾਰ ਸੁਮੇਲਿਤ ਕੀਤਾ ਜਾਵੇ—ਤਾਕਿ ਪ੍ਰਣਾਲੀ ਉਸ ਚੀਜ਼ 'ਤੇ ਤੇਜ਼ ਹੋਵੇ ਜੋ ਤੁਸੀਂ ਅਸਲ ਵਿੱਚ ਚਲਾਉਂਦੇ ਹੋ, ਨਾ ਕਿ ਉਸ ਚੀਜ਼ ਤੇ ਜੋ ਸਪੈਕ-ਸ਼ੀਟ 'ਤੇ ਚੰਗੀ ਲੱਗਦੀ ਹੈ।

ਅਮਲ ਵਿੱਚ ਕੋ-ਡਿਜ਼ਾਈਨ ਕਿਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ

ਇੱਕ ਕਲਾਸਿਕ ਉਦਾਹਰਨ ਹੈ ਕੰਪਾਇਲਰ ਸਹਾਇਤਾ ਜੋ ਹਾਰਡਵੇਅਰ ਲਾਭ ਖੋਲ੍ਹਦੀ ਹੈ। ਇੱਕ ਪ੍ਰੋਸੈਸਰ ਕੋਲ ਵੱਡੇ ਵੇਕਟਰ ਯੂਨਿਟ (SIMD), ਬਰਾਂਚ ਪ੍ਰਿਡਿਕਸ਼ਨ, ਜਾਂ ਇੰਸਟ੍ਰਕਸ਼ਨ ਹੋ ਸਕਦੀਆਂ ਹਨ ਜੋ ਓਪਰੇਸ਼ਨਾਂ ਨੂੰ ਫਿਊਜ਼ ਕਰਦੀਆਂ ਹਨ, ਪਰ ਸੋਫਟਵੇਅਰ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਬਣਾਇਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਕੰਪਾਇਲਰ ਉਸਦਾ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਵਰਤ ਸਕੇ।

• ਆਟੋ-ਵੇਕਟੋਰਾਈਜ਼ੇਸ਼ਨ: ਜੇ ਕੋਡ ਸਪਸ਼ਟ ਲੂਪਾਂ ਅਤੇ ਆਰੇ-ਅਧਾਰਿਤ ਕੰਮ ਵਰਗਾ ਹੈ (ਅਤੇ ਦਰੁਸ਼ਟੀ pointer aliasing ਤੋਂ ਬਚਦਾ ਹੈ), ਤਾਂ ਕੰਪਾਇਲਰ ਵੈਕਟਰ ਇੰਸਟ੍ਰਕਸ਼ਨਾਂ ਬਣਾਉਣ ਦੀ ਸੰਭਾਵਨਾ ਵadhਦੀ ਹੈ।
• ਪ੍ਰੋਫ਼ਾਈਲ-ਗਾਇਡਡ ਓਪਟੀਮਾਈਜ਼ੇਸ਼ਨ (PGO): ਅਸਲ ਐਗਜ਼ਿਕਿਊਸ਼ਨ ਪ੍ਰੋਫ਼ਾਈਲ ਨਾਲ ਕੰਪਾਇਲ ਕਰਕੇ, ਕੰਪਾਇਲਰ ਕੋਡ ਲੇਆਊਟ and branch behavior ਨੂੰ ਦੁਬਾਰਾ সাজਾ ਸਕਦਾ ਹੈ—CPU ਨੂੰ ਮਿਸਪ੍ਰਿਡਿਕਸ਼ਨਾਂ 'ਤੇ ਘੱਟ ਸਮਾਂ ਬਿਤਾਉਣਾ ਹੋਵੇ।
• ਡਾਟਾ ਲੇਆਊਟ ਚੋਣਾਂ: “array of structs” ਤੋਂ “struct of arrays” ਵੱਲ ਜਾਣਾ ਮੈਮੋਰੀ ਐਕਸੈਸ ਨੂੰ ਵਧੀਆਂ ਤਰ੍ਹਾਂ ਨਿਯਮਤ ਕਰ ਸਕਦਾ ਹੈ, ਜਿਸ ਨਾਲ caches ਅਤੇ prefetching ਬਿਹਤਰ ਕੰਮ ਕਰਦੇ ਹਨ।

ਕਿਉਂ “ਤੇਜ਼ ਹਾਰਡਵੇਅਰ” ਅਕਸਰ ਨਿਰਾਸ਼ਾਜਨਕ ਹੁੰਦਾ ਹੈ

ਜੇ ਬੋਤਲਨੈਕ ਮੇਮੋਰੀ ਸਟਾਲ, ਲਾਕ ਕੰਟੈਂਸ਼ਨ, ਜਾਂ I/O ਹੈ, ਤਾਂ ਉੱਚ ਕਲਾਕ ਸਪੀਡ ਜਾਂ ਹੋਰ ਕੋਰ ਆਮ ਤੌਰ 'ਤੇ ਨਤੀਜਾ ਨਹੀਂ ਬਦਲਦੇ। ਸਿਸਟਮ ਸਿਰਫ਼ ਉਸੇ ਸੀਮਾ ਤੇ ਤੇਜ਼ੀ ਨਾਲ ਪਹੁੰਚਦਾ ਹੈ। ਬਿਨਾਂ ਸੋਫਟਵੇਅਰ ਬਦਲਾਵਾਂ ਦੇ—ਚੰਗੀ ਪੈਰਾਲਲ ਬਣਤਰ, ਘੱਟ cache miss, ਘੱਟ ਸਿੰਕਰੋਨਾਈਜ਼ੇਸ਼ਨ—ਨਵਾ ਹਾਰਡਵੇਅਰ ਬੇਕਾਰ ਪੈ ਸਕਦਾ ਹੈ।

ਇੱਕ ਪ੍ਰਯੋਗਿਕ ਕੋ-ਡਿਜ਼ਾਈਨ ਚੈੱਕਲਿਸਟ

ਇੱਕ ਓਪਟੀਮਾਈਜ਼ੇਸ਼ਨ ਜਾਂ ਨਵੇਂ ਪਲੇਟਫਾਰਮ ਬਾਰੇ ਸੋਚਦੇ ਸਮੇਂ, ਪੁੱਛੋ:

1. ਵਰਕਲੋਡ: ਟੌਪ 1–3 ਆਲਾਮਕਾਰੀ ਕੰਮ ਕੀ ਹਨ (ਰਿਕਵੈਸਟ, ਕ੍ਵੈਰੀ, ਫਰੇਮ, ਜੌਬ)?
2. ਬੋਤਲਨੈਕ: ਸਮਾਂ ਕਿੱਥੇ ਲੱਗ ਰਿਹਾ ਹੈ—ਕੰਪਿਊਟ, ਮੇਮੋਰੀ, ਸਿੰਕਰੋਨਾਈਜ਼ੇਸ਼ਨ, ਜਾਂ I/O?
3. ਮਾਪਣਯੋਗ ਟਾਰਗੇਟ: ਕਿਹੜਾ ਮੈਟ੍ਰਿਕ ਸੁਧਰੇਗਾ (p95 ਲੇਟੈਂਸੀ, ਥਰਪੁਟ, ਹਰ ਟਾਸਕ ਲਈ ਊਰਜਾ), ਅਤੇ ਕਿੰਨਾ?

RISC ਅਤੇ ਸਾਦਗੀ ਦੀ ਕੀਮਤ

RISC (Reduced Instruction Set Computing) ਇੱਕ ਨੀਤੀਕ ਬਹਿਬੁਤ ਹੈ: ਜੇ ਤੁਸੀਂ ਇੰਸਟ੍ਰਕਸ਼ਨ ਸੈਟ ਨੂੰ ਛੋਟਾ ਅਤੇ ਨਿਯਮਤ ਰੱਖਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਹਰ ਇੰਸਟਰਕਸ਼ਨ ਨੂੰ ਤੇਜ਼ ਅਤੇ ਪੇਸ਼ਗੋਈਯੋਗ ਬਣਾਉਣ ਵਿੱਚ ਸਫਲ ਹੋ ਸਕਦੇ ਹੋ। John Hennessy ਨੇ ਇਸ ਨਜ਼ਰੀਏ ਨੂੰ ਲੋਕ-ਪ੍ਰਚਲਿਤ ਕੀਤਾ ਕਿ ਬਹੁਤ ਵਾਰੀ ਪ੍ਰਦਰਸ਼ਨ ਸੁਧਾਰ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਹਾਰਡਵੇਅਰ ਦਾ ਕੰਮ ਸਧਾਰਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਭਾਵੇਂ ਸੌਫਟਵੇਅਰ ਜ਼ਿਆਦਾ ਇੰਸਟ੍ਰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰੇ।

“ਸਧਾਰਨ ਇੰਸਟ੍ਰਕਸ਼ਨ” ਤੁਹਾਨੂੰ ਕੀ ਦਿੰਦੇ ਹਨ

ਇੱਕ ਸਟ੍ਰੀਮਲਾਈਨਡ ਇੰਸਟ੍ਰਕਸ਼ਨ ਸੈਟ ਅਕਸਰ ਸਥਿਰ ਫਾਰਮੈਟ ਅਤੇ ਸਿੱਧੇ ਓਪਰੇਸ਼ਨਾਂ (load, store, add, branch) ਰੱਖਦਾ ਹੈ। ਇਹ ਨਿਯਮਿਤਤਾ CPU ਲਈ ਇਹ ਸਭ ਪ੍ਰਸਾਰਤ ਕਰਦੀ ਹੈ:

• ਇੰਸਟਰਕਸ਼ਨਾਂ ਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਡੀਕੋਡ ਕਰਨਾ
• ਪਾਈਪਲਾਈਨ ਨੂੰ ਭਰਿਆ ਰੱਖਣਾ (ਇੰਸਟਰਕਸ਼ਨ ਦੇ ਮਤਲਬ ‘ਦੱਸਣ’ ਵਿੱਚ ਘੱਟ ਸਮਾਂ ਲੱਗਦਾ ਹੈ)
• ਅੰਦਰੂਨੀ ਯੂਨਿਟਾਂ ਵਿਚ ਕੰਮ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਤਰੀਕੇ ਨਾਲ ਸ਼ਡਿਊਲ ਕਰਨਾ

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

ਕਿਉਂ ਸਾਦਗੀ ਪਰਫਾਰਮੈਂਸ ਅਤੇ ਕੁਸ਼ਲਤਾ ਦੋਹਾਂ ਸੁਧਾਰ ਸਕਦੀ ਹੈ

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

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

ਆਧੁਨਿਕ ਸਿਸਟਮਾਂ ਵਿੱਚ RISC ਦਾ ਪ੍ਰਭਾਵ

ਆਧੁਨਿਕ CPUs—ਚਾਹੇ ਫ਼ੋਨ, ਲੈਪਟਾਪ, ਜਾਂ ਸਰਵਰ—RISC-ਸਟਾਇਲ ਸਿਧਾਂਤਾਂ ਤੋਂ ਬਹੁਤ ਕੁਝ ਲੈਂਦੇ ਹਨ: ਨਿਯਮਤ ਪਾਈਪਲਾਈਨ, ਸਧਾਰਨ ਆਪਰੇਸ਼ਨਾਂ 'ਤੇ ਬਹੁਤ ਅਪਟਿਮਾਈਜ਼ੇਸ਼ਨ, ਅਤੇ ਕੰਪਾਇਲਰਾਂ 'ਤੇ ਭਾਰੀ ਨਿਰਭਰਤਾ। ARM-ਅਧਾਰਿਤ ਸਿਸਟਮ ਇੱਕ ਵਿਆਪਕ ਰੂਪ ਵਿੱਚ RISC ਵਿਰਾਸਤ ਦਾ ਨਮੂਨਾ ਹਨ, ਪਰ ਵੱਡੀ ਸਿੱਖਿਆ ਇਹ ਨਹੀਂ ਕਿ “ਕਿਹੜਾ ਬ੍ਰੈਂਡ ਜਿੱਤਦਾ ਹੈ।”

ਟਿਕਾਊ ਸਿਧਾਂਤ ਇਹ ਹੈ: ਜਦੋਂ ਸਾਦਗੀ ਜ਼ਿਆਦਾ throughput, ਬਿਹਤਰ ਕੁਸ਼ਲਤਾ, ਅਤੇ ਸਕੇਲਿੰਗ ਆਸਾਨ ਬਣਾਉਂਦੀ ਹੋਏ ਮਦਦ ਕਰੇ, ਤਾਂ ਸਾਦਗੀ ਚੁਣੋ।

ਸਪੈਸ਼ਲਾਈਜ਼ੇਸ਼ਨ ਅਤੇ ਐਕਸੇਲੇਰੇਟਰ: ਜਦੋਂ ਜਨਰਲ CPUs ਕਾafi ਨਹੀਂ ਹੁੰਦੇ

ਸਪੈਸ਼ਲਾਈਜ਼ੇਸ਼ਨ ਦਾ ਮਤਲਬ ਉਹ ਹਾਰਡਵੇਅਰ ਵਰਤਣਾ ਹੈ ਜੋ ਇੱਕ ਕਿਸਮ ਦੇ ਕੰਮ ਨੂੰ ਬਹੁਤ ਅਚਛੇ ਢੰਗ ਨਾਲ ਕਰਦਾ ਹੈ, ਬਜਾਏ ਇਸਦੇ ਕਿ ਜਨਰਲ-ਪਪਰਪਜ਼ CPU ਸਭ ਕੁਝ ਕਰੇ। ਆਮ ਉਦਾਹਰਨਾਂ ਵਿੱਚ GPUs ਗ੍ਰਾਫਿਕਸ ਅਤੇ ਪੈਰਾਲਲ ਗਣਿਤ ਲਈ, AI ਐਕਸੇਲੇਰੇਟਰ (NPUs/TPUs) ਮੈਟ੍ਰਿਕਸ ਓਪਰੇਸ਼ਨ ਲਈ, ਅਤੇ ਫਿਕਸਡ-ਫੰਕਸ਼ਨ ਬਲਾਕ ਜਿਵੇਂ ਵੀਡੀਓ ਕੋਡੈਕ (H.264/HEVC/AV1) ਸ਼ਾਮਲ ਹਨ।

ਐਕਸੇਲੇਰੇਟਰ ਕਿਉਂ ਤੇਜ਼ ਅਤੇ ਊਰਜਾ-ਸੰਤੁਲਿਤ ਹੋ ਸਕਦੇ ਹਨ

CPU ਲਚੀਲੇਪਣ ਲਈ ਡਿਜ਼ਾਈਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ: ਬਹੁਤ ਸਾਰੀਆਂ ਇੰਸਟਰਕਸ਼ਨਾਂ, ਕਾਫ਼ੀ ਕੰਟਰੋਲ ਲੋਜਿਕ, ਅਤੇ “ਬਰਾਂਚੀ” ਕੋਡ ਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਸੰਭਾਲਣਾ। ਐਕਸੇਲੇਰੇਟਰ ਇਸ ਲਚੀਲੇਪਣ ਨੂੰ ਛੱਡ ਕੇ ਕੁਸ਼ਲਤਾ ਲਈ ਵਪਾਰ ਕਰਦੇ ਹਨ। ਉਹ ਚਿਪ ਬਜਟ ਦਾ ਵੱਧ ਹਿੱਸਾ ਦਰਸਾਈਆਂ ਜਾਣ ਵਾਲੀਆਂ ਓਪਰੇਸ਼ਨਾਂ (ਜਿਵੇਂ multiply–accumulate) ਵਿੱਚ ਰੱਖਦੇ ਹਨ, ਕੰਟਰੋਲ ਓਵਰਹੈੱਡ ਘਟਾਉਂਦੇ ਹਨ, ਅਤੇ ਅਕਸਰ ਘੱਟ precision (ਜਿਵੇਂ INT8 ਜਾਂ FP16) ਵਰਤਦੇ ਹਨ ਜਿੱਥੇ ਸਹੀ ਹੈ।

ਇਸ ਫੋਕਸ ਦਾ ਮਤਲਬ ਹੈ ਹਰ ਵਾਟ ਉੱਤੇ ਹੋਰ ਕੰਮ: ਘੱਟ ਇੰਸਟਰਕਸ਼ਨ, ਘੱਟ ਡਾਟਾ ਹਿਲਚਲ, ਅਤੇ ਹੋਰ ਪੈਰਾਲਲ ਐਕਜ਼ਿਕਿਊਸ਼ਨ। ਜੇ ਵਰਕਲੋਡ ਇੱਕ ਦੁਹਰਾਏ ਜਾਣ ਵਾਲੇ kernel (ਰੈਂਡਰਿੰਗ, ਇਨਫੇਰੈਂਸ, ਏਨਕੋਡਿੰਗ) ਤੋਂ ਪ੍ਰਧਾਨ ਹੈ, ਤਾਂ ਇਹ ਡਰੈਮੈਟਿਕ ਤੇਜ਼ੀ ਅਤੇ ਊਰਜਾ ਬਚਤ ਦੇ ਸਕਦਾ ਹੈ।

ਉਹ ਟਰੇਡਆਫ਼ਸ ਜਿਨ੍ਹਾਂ ਨੂੰ ਤੁਸੀਂ ਨਜ਼ਰਅੰਦਾਜ਼ ਨਹੀਂ ਕਰ ਸਕਦੇ

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

ਸਪੈਸ਼ਲਾਈਜ਼ੇਸ਼ਨ ਕਦੋਂ ਲਾਇਕ ਹੈ?

ਇੱਕ ਐਕਸੇਲੇਰੇਟਰ ਚੁਣੋ ਜਦ:

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

Jਦ ਵਰਕਲੋਡ ਅਨਿਯਮ, ਤੇਜ਼ੀ ਨਾਲ ਬਦਲਣ ਵਾਲਾ, ਜਾਂ ਸੋਫਟਵੇਅਰ ਲਾਗਤ ਬਚਤ ਤੋਂ ਵੱਧ ਹੋਵੇ, ਤਾਂ CPUs ਨਾਲ ਰਹੋ।

ਟਰੇਡਆਫ਼ਸ: ਕੋਈ ਵੀ ਆਰਕੀਟੈਕਚਰ ਫੈਸਲਾ ਮੁਫ਼ਤ ਨਹੀਂ

ਕੰਪਿਊਟਰ ਆਰਕੀਟੈਕਚਰ ਵਿੱਚ ਹਰ ਪਰਫਾਰਮੈਂਸ “ਜਿੱਤ” ਦੀ ਇਕ ਬਿੱਲ ਹੁੰਦੀ ਹੈ। Hennessy ਦਾ ਕੰਮ ਮੁੜ-ਮੁੜ ਇਸ ਤੱਥ 'ਤੇ ਵਾਪਸ ਆਉਂਦਾ ਹੈ: ਸਿਸਟਮ ਨੂੰ ਓਪਟੀਮਾਈਜ਼ ਕਰਨਾ ਇਹ ਚੁਣਨ ਹੈ ਕਿ ਤੁਸੀਂ ਕੀ ਦੇਣ ਲਈ ਤਿਆਰ ਹੋ।

ਮੁੱਖ ਟਰੇਡਆਫ਼ਸ ਜਿਨ੍ਹਾਂ ਤੋਂ ਬਚਿਆ ਨਹੀਂ ਜਾ ਸਕਦਾ

ਕੁਝ ਤਣਾਅ ਵਾਰ-ਵਾਰ ਉੱਭਰਦੇ ਹਨ:

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

ਜਦ ਇੱਕ ਮੈਟ੍ਰਿਕ ਸੁਧਰਦਾ ਹੈ, ਦੂਜਾ ਅਕਸਰ ਖਰਾਬ ਹੁੰਦਾ ਹੈ

ਇੱਕ ਨੰਬਰ ਲਈ ਓਪਟਿਮਾਈਜ਼ ਕਰਨਾ ਆਸਾਨ ਹੈ ਪਰ ਉਪਭੋਗਤਾ ਦੇ ਅਸਲ ਤਜਰਬੇ ਨੂੰ ਖਰਾਬ ਕਰ ਦੇਣਾ ਵੀ ਆਸਾਨ ਹੈ।

ਉਦਾਹਰਨ ਲਈ, ਕਲਾਕ ਸਪੀਡ ਵਧਾਉਣਾ ਪਾਵਰ ਅਤੇ ਹੀਟ ਵਧਾ ਸਕਦਾ ਹੈ, ਜਿਸ ਨਾਲ throttling ਹੁੰਦਾ ਹੈ ਜੋ ਲੰਬੇ ਸਮੇਂ ਦੀ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਨੁਕਸਾਨ ਪਹੁੰਚਾ ਸਕਦਾ ਹੈ। ਕੋਰ ਵਧਾਉਣਾ ਪੈਰਾਲਲ ਥਰਪੁੱਟ ਨੂੰ ਸੁਧਾਰ ਸਕਦਾ ਹੈ, ਪਰ ਇਹ ਮੇਮੋਰੀ ਕੰਟੈਂਸ਼ਨ ਵਧਾ ਸਕਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਹਰ ਕੋਰ ਘੱਟ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਬਣ ਜਾਏ। ਵੱਡਾ cache misses ਘਟਾ ਸਕਦਾ ਹੈ (ਲੈਟੈਂਸੀ ਲਈ ਚੰਗਾ) ਪਰ ਚਿਪ ਇਲਾਕਾ ਅਤੇ ਹਰ ਐਕਸੈਸ ਲਈ ਊਰਜਾ ਵਧਾ ਸਕਦਾ ਹੈ (ਲਾਗਤ ਅਤੇ ਕੁਸ਼ਲਤਾ ਲਈ ਮਾੜਾ)।

ਵਰਕਲੋਡ ਲਈ ਡਿਜ਼ਾਈਨ ਕਰੋ, ਸ਼ਾਨਦਾਰ ਨੰਬਰਾਂ ਲਈ ਨਹੀਂ

Hennessy ਦਾ ਪ੍ਰਤੀਖ ਅਸਲਵਾਦੀ ਹੈ: ਉਸ ਵਰਕਲੋਡ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ ਜਿਸਦੀ ਤੁਸੀਂ ਪਰਵਾਹ ਕਰਦੇ ਹੋ, ਫਿਰ ਉਸ ਹਕੀਕਤ ਲਈ ਓਪਟਿਮਾਈਜ਼ ਕਰੋ।

ਇੱਕ ਸਰਵਰ ਜੋ ਲੱਖਾਂ ਸਮਾਨ ਰਿਕਵੈਸਟ ਹੈ, predictable throughput ਅਤੇ ਹਰ ਓਪਰੇਸ਼ਨ ਲਈ ਊਰਜਾ ਦੀ ਪਰਵਾਹ ਕਰੇਗਾ। ਇਕ ਲੈਪਟੌਪ responsiveness ਅਤੇ ਬੈਟਰੀ ਜੀਵਨ ਦੀ ਪਰਵਾਹ ਕਰੇਗਾ। ਇਕ ਡੇਟਾ ਪਾਈਪਲਾਈਨ ਜੇਕਰ ਕੁੱਲ ਜੌਬ ਸਮੇਂ ਸੁਧਰੇ ਤਾਂ ਉੱਚ ਲੈਟੈਂਸੀ ਮਨਜ਼ੂਰ ਕਰ ਸਕਦਾ ਹੈ। ਬੈਂਚਮਾਰਕ ਅਤੇ ਸਿਰ-ਬਦ ਨੰਬਰ ਲਾਭਦਾਇਕ ਹਨ, ਪਰ ਸਿਰਫ ਜੇ ਉਹ ਤੁਹਾਡੀ ਅਸਲ ਵਰਤੋਂਕੇਸ ਨੂੰ ਮਿਲਦੇ ਹਨ।

ਇੱਕ ਨੋਟ ਜੋ ਤੁਸੀਂ ਬਾਅਦ ਵਿੱਚ ਲਾਗੂ ਕਰ ਸਕਦੇ ਹੋ

ਇੱਕ ਛੋਟੀ ਟੇਬਲ ਜੋ ਇਹ ਵੇਖਾਵੇ: ਫੈਸਲਾ, ਮਦਦ ਕਰਦਾ ਹੈ, ਨੁਕਸਾਨ, ਸਭ ਤੋਂ ਵਧੀਆ. ਕਤਾਰਾਂ ਵਿੱਚ “ਹੋਰ ਕੋਰ”, “ਵੱਡਾ cache”, “ਉੱਚ ਫ੍ਰਿਕਵੈਂਸੀ”, “ਚੌੜੇ ਵੇਕਟਰ ਯੂਨਿਟ”, ਅਤੇ “ਤੇਜ਼ ਮੇਮੋਰੀ” ਸ਼ਾਮਲ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਇਹ ਟਰੇਡਆਫ਼ਸ ਨੂੰ ਠੋਸ ਬਣਾਉਂਦੀ ਹੈ—ਅਤੇ ਚਰਚਾ ਨੂੰ ਨਤੀਜਿਆਂ ਨਾਲ ਜੋੜੀ ਰੱਖਦੀ ਹੈ, ਨਾ ਕਿ ਹੈਪ।

ਪਰਫਾਰਮੈਂਸ ਮਾਪਣਾ ਤੇ ਆਪਣੀ ਨੁਕਸਮਤੀ ਤੋਂ ਬਚਣਾ

ਪਰਫਾਰਮੈਂਸ ਦਾਅਵੇ ਉਨ੍ਹਾਂ ਮਾਪਣਾਂ ਦੇ ਅਨੁਪਾਤੀ ਹੁੰਦੇ ਹਨ। ਇੱਕ ਬੈਂਚਮਾਰਕ ਪੂਰੀ ਤਰ੍ਹਾਂ “ਸਹੀ” ਹੋ ਸਕਦੀ ਹੈ ਅਤੇ ਫਿਰ ਵੀ ਗੁਮਰਾਹ ਕਰਨ ਵਾਲੀ ਹੋ ਸਕਦੀ ਹੈ ਜੇ ਇਹ ਤੁਹਾਡੇ ਅਸਲ ਵਰਕਲੋਡ ਵਰਗੀ ਨਾ ਹੋਵੇ: ਡਾਟਾ ਆਕਾਰ, cache ਵਿਵਹਾਰ, I/O ਢਾਂਚਾ, konkurrence, ਜਾਂ पढ़ਨ-ਲਿਖਨ ਦਾ ਮਿਸ਼ਰਣ ਨਤੀਜਾ ਪੂਰਾ ਉਲਟ ਹੋ ਸਕਦਾ ਹੈ। ਇਸੀ ਲਈ Hennessy ਧਾਰਾ-ਪੰਥੀ ਬੈਂਚਮਾਰਕਿੰਗ ਨੂੰ ਪ੍ਰਯੋਗ ਮੰਨਦਾ ਹੈ, ਇਨਾਮ ਨਹੀਂ।

ਉਹ ਮੈਟ੍ਰਿਕ ਜੋ ਵਰਤੋਂਕਾਰ ਅਨੁਭਵ ਸਮਝਾਉਂਦੇ ਹਨ

ਥਰਪੁੱਟ ਇਹ ਹੈ ਕਿ ਤੁਸੀਂ ਇਕਾਈ ਸਮੇਂ ਵਿੱਚ ਕਿੰਨਾ ਕੰਮ ਮੁਕੰਮਲ ਕਰੋ (requests/second, jobs/hour)। ਇਹ ਛੇਤੀ ਸਮਰੱਥਾ ਯੋਜਨਾ ਲਈ ਚੰਗਾ ਹੈ, ਪਰ ਉਪਭੋਗਤਾ ਔਸਤਾਂ ਨਹੀਂ ਮਹਿਸੂਸ ਕਰਦੀ।

ਟੇਲ ਲੈਟੈਂਸੀ ਸਭ ਤੋਂ ਧੀਮੀ ਰਿਕਵੇਸਟਾਂ 'ਤੇ ਧਿਆਨ ਕੇਂਦ੍ਰਿਤ ਕਰਦੀ ਹੈ—ਅਕਸਰ p95/p99 ਰਿਪੋਰਟ ਕੀਤਾ ਜਾਂਦਾ। ਇੱਕ ਸਿਸਟਮ ਦੇ ਔਸਤ ਲੈਟੈਂਸੀ ਚੰਗੀ ਹੋ ਸਕਦੀ ਹੈ ਪਰ p99 ਬਹੁਤ ਖਰਾਬ ਹੋ ਸਕਦੀ ਹੈ ਕਿਉਂਕਿ queueing, GC ਪੌਜ਼, ਲਾਕ ਕੰਟੈਂਸ਼ਨ, ਜਾਂ noisy neighbors ਹਨ।

ਯੂਟਿਲਾਈਜ਼ੇਸ਼ਨ ਇਹ ਦਿਖਾਂਦਾ ਹੈ ਕਿ ਇਕ ਸਰੋਤ ਕਿੰਨਾ “ਬਿਜੀ” ਹੈ (CPU, ਮੇਮੋਰੀ ਬੈਂਡਵਿਡਥ, ਡਿਸਕ, ਨੈਟਵਰਕ)। ਉੱਚ ਯੂਟੀਲਾਈਜ਼ੇਸ਼ਨ ਚੰਗਾ ਹੋ ਸਕਦਾ ਹੈ—ਜਦ ਤੱਕ ਇਹ ਤੁਹਾਨੂੰ ਲੰਬੀਆਂ ਕਤਾਰਾਂ ਵਿੱਚ ਨਹੀਂ ਧੱਕਦਾ ਜਿੱਥੇ ਟੇਲ ਲੈਟੈਂਸੀ ਉੱਡ ਜਾਂਦੀ ਹੈ।

ਇੱਕ ਪ੍ਰਯੋਗਿਕ ਮੁਲਾਂਕਣ ਲੂਪ

ਇੱਕ ਦੁਹਰਾਓਯੋਗ ਲੂਪ ਵਰਤੋ:

1. ਮਾਪੋ ਨੁਮੂਨਯੋਗ ਇਨਪੁੱਟ ਅਤੇ ਹਕੀਕਤ-ਮੁਤਾਬਕ concurency 'ਤੇ।
2. ਇੱਕ ਚੀਜ਼ ਬਦਲੋ (ਕੰਪਾਇਲਰ ਫਲੈਗ, ਥ੍ਰੈਡ ਗਿਣਤੀ, ਡਾਟਾ ਲੇਆਊਟ, caching ਨੀਤੀ, ਹਾਰਡਵੇਅਰ ਸੈਟਿੰਗ)।
3. ਮਾਪੋ ਫਿਰ, ਅਤੇ ਸਿਰਫ ਤਰਮਾ ਨਤੀਜਿਆਂ ਹੀ ਨਹੀਂ, ਪਰ ਵੈਰੀਏਬਿਲਿਟੀ ਅਤੇ ਟੇਲ ਨੂੰ ਵੀ ਤੁਲਨਾ ਕਰੋ।

ਕੰਫਿਗਰੇਸ਼ਨ, ਵਰਜ਼ਨ, ਅਤੇ ਵਾਤਾਵਰਣ ਦੀਆਂ ਨੋਟਸ ਰੱਖੋ ਤਾਂ ਜੋ ਤੁਸੀਂ ਬਾਅਦ ਵਿੱਚ ਨਤੀਜੇ ਦੁਹਰਾ ਸਕੋ।

ਖੁਦ-ਨਿਰਮਿਤ ਗਲਤ ਫੈਸਲਿਆਂ ਤੋਂ ਬਚੋ

“ਸਭ ਤੋਂ ਵਧੀਆ ਦੌੜ” ਨੂੰ ਚੁਣਨਾ, ਦੋਸਤਾਨਾ ਡੇਟਾ-ਸੈਟ ਚੁਣਨਾ, ਜਾਂ ਇਕ ਇੱਕ ਮੈਟ੍ਰਿਕ ਜੋ ਤੁਹਾਡੇ ਬਦਲਾਵ ਨੂੰ ਚਮਕਾਉਂਦਾ ਹੈ—ਇਹ ਸਭ ਗਲਤ ਹਨ। ਅਤੇ ਇਹ ਨਾ سوچੋ ਕਿ ਇੱਕ ਮਸ਼ੀਨ ਜਾਂ ਬੈਂਚਮਾਰਕ ਸੂਟ 'ਤੇ ਜਿੱਤ ਤੁਹਾਡੇ ਡਿਪਲੋਯਮੈਂਟ, ਲਾਗਤ ਸੀਮਾਵਾਂ, ਜਾਂ ਉਪਭੋਗਤਾ ਦੇ ਪੀਕ-ਘੰਟੇ ਟ੍ਰੈਫਿਕ ਲਈ ਹੋਵੇਗੀ।

ਮੁੱਖ ਨਿੱਕਾਰਾਂ ਅਤੇ ਅੱਜ ਇਹਨੂੰ ਕਿਵੇਂ ਲਾਗੂ ਕਰੀਏ

Hennessy ਦਾ ਕਾਇਮੀ ਸੁਨੇਹਾ ਪ੍ਰਯੋਗਿਕ ਹੈ: ਪਰਫਾਰਮੈਂਸ ਖੁਆਹਿਸ਼ ਨਾਲ ਨਹੀਂ ਵਧਦੀ—ਇਹ ਉਸ ਵੇਲੇ ਵਧਦੀ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਠੀਕ ਤਰ੍ਹਾਂ ਦਾ ਪੈਰਾਲਲਿਜ਼ਮ ਚੁਣੋ, ਊਰਜਾ ਸੀਮਾਵਾਂ ਦਾ ਸਨਮਾਨ ਕਰੋ, ਅਤੇ ਉਹ ਵਰਕਲੋਡ optimize ਕਰੋ ਜੋ ਅਸਲ ਵਿੱਚ ਮਹੱਤਵ ਰੱਖਦੀ ਹੈ।

ਰਣਨੀਤਿਕ ਪਾਠ

ਪੈਰਾਲਲਿਜ਼ਮ ਮੁੱਖ ਰਸਤਾ ਹੈ, ਪਰ ਇਹ ਕਦੇ ਵੀ "ਮੁਫ਼ਤ" ਨਹੀਂ ਹੁੰਦਾ। ILP ਹੋਵੇ, ਮਲਟੀਕੋਰ ਥਰਪੁੱਟ ਹੋਵੇ, ਜਾਂ ਐਕਸੇਲੇਰੇਟਰ—ਸੌਖੇ ਗੇਨ ਖਤਮ ਹੋ ਜਾਂਦੇ ਹਨ ਅਤੇ ਸੰਯੋਜ਼ਨ ਓਵਰਹੈੱਡ ਵਧਦਾ ਹੈ।

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

ਵਰਕਲੋਡ-ਕੇਂਦਰਤ ਓਪਟੀਮਾਈਜ਼ੇਸ਼ਨ ਜਨਰਲ ਓਪਟੀਮਾਈਜ਼ੇਸ਼ਨ ਤੇ ਜਿੱਤਦਾ ਹੈ। Amdahl’s Law ਯਾਦ ਦਿਲਾਉਂਦੀ ਹੈ ਕਿ ਕਿਸੇ ਹਿੱਸੇ ਨੂੰ ਤੇਜ਼ ਕਰਨ ਦਾ ਅਧਿਕਤਮ ਲਾਭ ਕੀ ਹੋ ਸਕਦਾ ਹੈ। ਪਹਿਲਾਂ ਪ੍ਰੋਫ਼ਾਈਲ ਕਰੋ; ਫਿਰ ਓਪਟੀਮਾਈਜ਼ ਕਰੋ।

ਨਿਰਮਾਤਿਆਂ ਲਈ ਪ੍ਰਯੋਗਿਕ ਚੈਕਲਿਸਟ

• ਮਾਪਣ ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ: ਬਦਲਾਅ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਅਗਲੇ ਟਾਪ ਬੋਤਲਨੈਕ (CPU, ਮੇਮੋਰੀ, ਸਟੋਰੇਜ, ਨੈਟਵਰਕ) ਦੀ ਪਛਾਣ ਕਰੋ।
• ਯੋਜਨਾ ਵਿੱਚ Amdahl’s Law ਵਰਤੋ: ਪੈਰਾਲਲਾਈਜ਼ੇਸ਼ਨ ਵਿੱਚ ਨਿਵੇਸ਼ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਅਦਿਕਤਮ ਲਾਭ ਦਾ ਅੰਦਾਜ਼ਾ ਲਗਾਓ।
• ਸਾਦੇ, ਸਕੇਲੇਬਲ ਡਿਜ਼ਾਈਨਾਂ ਨੂੰ ਤਰਜੀਹ ਦਿਓ: ਘੱਟ ਖਾਸ ਕੇਸ ਆਮ ਤੌਰ 'ਤੇ ਭਲਕੇ ਨਤੀਜੇ ਅਤੇ ਸਹੀ-ਅਨੁਕੂਲ ਟਿਊਨਿੰਗ ਮਿਲਦੀ ਹੈ।
• ਪਹਿਲੇ ਦਿਨ ਤੋਂ ਪਾਵਰ ਅਤੇ ਲਾਗਤ ਨੂੰ ਸੀਮਾਵਾਂ ਵਜੋਂ ਮੰਨੋ, ਨਾ ਕਿ ਬਾਅਦ ਦੀ ਚਿੰਤਾ।
• ਹਾਰਡਵੇਅਰ ਨੂੰ ਉਤਪਾਦ ਨਾਲ ਮਿਲਾਓ: GPU/NPUs ਸਿਰਫ਼ ਉਹਨਾਂ ਵਾਰ ਵਰਤੋ ਜਦੋਂ ਵਰਕਲੋਡ ਸਥਿਰ, ਚੰਗੀ ਤਰ੍ਹਾਂ ਸਮਝੀ ਹੋਈ, ਅਤੇ ਇੰਜੀਨੀਅਰਿੰਗ ਲਾਗਤ ਵਾਜਬ ਹੋਵੇ।

ਰੋਜ਼ਾਨਾ ਸੋਫਟਵੇਅਰ ਨਿਰਮਾਣ ਵਿੱਚ ਇਹ ਕਿਵੇਂ ਮਿਲਦਾ ਹੈ

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

ਰਵੇਂ ਟੀਮਾਂ ਜੋ chat-driven build workflow ਵਰਤ ਰਹੀਆਂ ਹਨ ਜਿਵੇਂ Koder.ai, ਇਸ ਤੋਂ ਖ਼ਾਸ ਫਾਇਦਾ ਉਠਾ ਸਕਦੀਆਂ ਹਨ: ਤੁਸੀਂ ਤੇਜ਼ੀ ਨਾਲ ਇੱਕ ਸਰਵਿਸ ਜਾਂ UI ਪ੍ਰੋਟੋਟਾਈਪ ਕਰ ਸਕਦੇ ਹੋ, ਫਿਰ ਪ੍ਰੋਫ਼ਾਈਲ ਅਤੇ ਬੈਂਚਮਾਰਕ ਦੇ ਆਧਾਰ ਤੇ ਫੈਸਲਾ ਕਰੋ ਕਿ ਕੀ ਪੈਰਾਲਲਿਜ਼ਮ (ਜਿਵੇਂ ਰਿਕਵੈਸਟ concurency) ਨੂੰ ਅਪਨਾਉਣਾ ਹੈ, ਡਾਟਾ ਲੋਕੈਲਿਟੀ ਸੁਧਾਰਨੀ ਹੈ (ਘੱਟ ਰਾਉਂਡ-ਟ੍ਰਿਪ, ਤੰਗ ਕ੍ਵੈਰੀ), ਜਾਂ ਸਪੈਸ਼ਲਾਈਜ਼ੇਸ਼ਨ ਲਿਆਉਨੀ ਹੈ (ਭਾਰੇ ਕੰਮ ਨੂੰ ਆਫਲੋਡ ਕਰਨਾ)। ਪਲੇਟਫਾਰਮ ਦਾ planning mode, snapshots, ਅਤੇ rollback ਉਨ੍ਹਾਂ ਬਦਲਾਵਾਂ ਨੂੰ ਕ੍ਰਮਬੱਧ ਤਰੀਕੇ ਨਾਲ ਟੈਸਟ ਕਰਨ ਨੂੰ ਆਸਾਨ ਬਣਾਉਂਦੇ ਹਨ—ਬਿਨਾਂ ਇਸਦੇ ਕਿ ਓਪਟੀਮਾਈਜ਼ੇਸ਼ਨ ਇੱਕ ਇਕ-ਤਰੀਕੇ ਦਾ ਰਸਤਾ ਬਣ ਜਾਵੇ।

ਹੋਰ ਪੜ੍ਹਾਈ ਲਈ

• John L. Hennessy \u0026 David A. Patterson, Computer Architecture: A Quantitative Approach.
• John L. Hennessy \u0026 David A. Patterson, Computer Organization and Design.
• Gene Amdahl, “Validity of the Single Processor Approach to Achieving Large Scale Computing Capabilities” (1967).
• Hennessy \u0026 Patterson, “A New Golden Age for Computer Architecture” (ACM Turing Lecture).

ਜੇ ਤੁਸੀਂ ਹੋਰ ਇਸ ਤਰ੍ਹਾਂ ਦੇ ਪੋਸਟ ਚਾਹੁੰਦੇ ਹੋ, ਸਾਡੇ ਬਲੌਗ ਵੇਖੋ।