ਕੰਪਿਊਟਰ ਪ੍ਰਣਾਲੀਆਂ ਦੇ ਸਿਮੂਲੇਟਰ: ਇੱਕ ਜਾਣਿਆ-ਪਛਾਣਿਆ ਫੁੱਲ-ਪਲੇਟਫਾਰਮ ਸਿਮੂਲੇਟਰ ਅਤੇ ਅਣਜਾਣ ਘੜੀ ਦੀ ਦਿਸ਼ਾ ਅਤੇ ਟਰੇਸ

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

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

ਪੂਰਾ ਪਲੇਟਫਾਰਮ ਸਿਮੂਲੇਟਰ, ਜਾਂ "ਫੀਲਡ ਵਿੱਚ ਇਕੱਲਾ ਯੋਧਾ ਨਹੀਂ ਹੈ"

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

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

ਹੇਠਾਂ Intel ਤੋਂ x58 ਚਿੱਪਸੈੱਟ ਦਾ ਇੱਕ ਬਲਾਕ ਚਿੱਤਰ ਹੈ। ਇਸ ਚਿੱਪਸੈੱਟ 'ਤੇ ਇੱਕ ਫੁੱਲ-ਪਲੇਟਫਾਰਮ ਕੰਪਿਊਟਰ ਸਿਮੂਲੇਟਰ ਲਈ ਜ਼ਿਆਦਾਤਰ ਸੂਚੀਬੱਧ ਯੰਤਰਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਜਿਸ ਵਿੱਚ IOH (ਇਨਪੁਟ/ਆਊਟਪੁੱਟ ਹੱਬ) ਅਤੇ ICH (ਇਨਪੁਟ/ਆਊਟਪੁੱਟ ਕੰਟਰੋਲਰ ਹੱਬ) ਦੇ ਅੰਦਰ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ, ਜੋ ਕਿ ਬਲਾਕ ਡਾਇਗ੍ਰਾਮ 'ਤੇ ਵੇਰਵੇ ਨਾਲ ਨਹੀਂ ਦਰਸਾਏ ਗਏ ਹਨ। . ਹਾਲਾਂਕਿ, ਜਿਵੇਂ ਕਿ ਅਭਿਆਸ ਦਿਖਾਉਂਦਾ ਹੈ, ਇੱਥੇ ਬਹੁਤ ਸਾਰੇ ਉਪਕਰਣ ਨਹੀਂ ਹਨ ਜੋ ਸੌਫਟਵੇਅਰ ਦੁਆਰਾ ਨਹੀਂ ਵਰਤੇ ਜਾਂਦੇ ਹਨ ਜੋ ਅਸੀਂ ਚਲਾਉਣ ਜਾ ਰਹੇ ਹਾਂ. ਅਜਿਹੇ ਯੰਤਰਾਂ ਦੇ ਮਾਡਲ ਬਣਾਉਣ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ।

ਬਹੁਤੇ ਅਕਸਰ, ਫੁੱਲ-ਪਲੇਟਫਾਰਮ ਸਿਮੂਲੇਟਰਾਂ ਨੂੰ ਪ੍ਰੋਸੈਸਰ ਨਿਰਦੇਸ਼ ਪੱਧਰ 'ਤੇ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ (ISA, ਹੇਠਾਂ ਦੇਖੋ). ਪਿਛਲੇ ਲੇਖ). ਇਹ ਤੁਹਾਨੂੰ ਸਿਮੂਲੇਟਰ ਨੂੰ ਮੁਕਾਬਲਤਨ ਤੇਜ਼ੀ ਨਾਲ ਅਤੇ ਸਸਤੇ ਢੰਗ ਨਾਲ ਬਣਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ISA ਪੱਧਰ ਵੀ ਚੰਗਾ ਹੈ ਕਿਉਂਕਿ ਇਹ ਘੱਟ ਜਾਂ ਘੱਟ ਸਥਿਰ ਰਹਿੰਦਾ ਹੈ, ਉਦਾਹਰਨ ਲਈ, API/ABI ਪੱਧਰ, ਜੋ ਅਕਸਰ ਬਦਲਦਾ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਹਦਾਇਤਾਂ ਦੇ ਪੱਧਰ 'ਤੇ ਲਾਗੂ ਕਰਨਾ ਤੁਹਾਨੂੰ ਅਖੌਤੀ ਅਣਸੋਧਿਆ ਬਾਈਨਰੀ ਸੌਫਟਵੇਅਰ ਚਲਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਯਾਨੀ ਪਹਿਲਾਂ ਤੋਂ ਹੀ ਕੰਪਾਇਲ ਕੀਤੇ ਕੋਡ ਨੂੰ ਬਿਨਾਂ ਕਿਸੇ ਬਦਲਾਅ ਦੇ ਚਲਾਓ, ਬਿਲਕੁਲ ਉਸੇ ਤਰ੍ਹਾਂ ਜਿਵੇਂ ਕਿ ਅਸਲ ਹਾਰਡਵੇਅਰ 'ਤੇ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਦੂਜੇ ਸ਼ਬਦਾਂ ਵਿੱਚ, ਤੁਸੀਂ ਆਪਣੀ ਹਾਰਡ ਡਰਾਈਵ ਦੀ ਇੱਕ ਕਾਪੀ ("ਡੰਪ") ਬਣਾ ਸਕਦੇ ਹੋ, ਇਸਨੂੰ ਇੱਕ ਫੁੱਲ-ਪਲੇਟਫਾਰਮ ਸਿਮੂਲੇਟਰ ਵਿੱਚ ਇੱਕ ਮਾਡਲ ਲਈ ਇੱਕ ਚਿੱਤਰ ਦੇ ਤੌਰ ਤੇ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ, ਅਤੇ ਵੋਇਲਾ! - OS ਅਤੇ ਹੋਰ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਬਿਨਾਂ ਕਿਸੇ ਵਾਧੂ ਕਾਰਵਾਈਆਂ ਦੇ ਸਿਮੂਲੇਟਰ ਵਿੱਚ ਲੋਡ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਸਿਮੂਲੇਟਰ ਪ੍ਰਦਰਸ਼ਨ

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

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

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

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

ਹੇਠਾਂ ਦਿੱਤਾ ਗ੍ਰਾਫ਼ ਮਾਡਲ ਵੇਰਵੇ 'ਤੇ ਸਿਮੂਲੇਸ਼ਨ ਸਪੀਡ ਦੀ ਅੰਦਾਜ਼ਨ ਨਿਰਭਰਤਾ ਦਿਖਾਉਂਦਾ ਹੈ।

ਬੀਟ-ਬਾਈ-ਬੀਟ ਸਿਮੂਲੇਸ਼ਨ

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

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

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

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

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

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

ਟਰੇਸ-ਅਧਾਰਿਤ ਸਿਮੂਲੇਸ਼ਨ

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

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

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

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

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

ਸਰੋਤ: www.habr.com