QEMU.js: ਹੁਣ ਗੰਭੀਰ ਤਰੀਕੇ ਨਾਲ ਅਤੇ WASM ਨਾਲ

ਇੱਕ ਵਾਰ ਤੇ ਮੈਂ ਮਜ਼ੇ ਲਈ ਫੈਸਲਾ ਕੀਤਾ ਪ੍ਰਕਿਰਿਆ ਦੀ ਉਲਟੀਯੋਗਤਾ ਨੂੰ ਸਾਬਤ ਕਰੋ ਅਤੇ ਮਸ਼ੀਨ ਕੋਡ ਤੋਂ JavaScript (ਵਧੇਰੇ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ, Asm.js) ਬਣਾਉਣਾ ਸਿੱਖੋ। QEMU ਨੂੰ ਪ੍ਰਯੋਗ ਲਈ ਚੁਣਿਆ ਗਿਆ ਸੀ, ਅਤੇ ਕੁਝ ਸਮੇਂ ਬਾਅਦ ਹਾਬਰ 'ਤੇ ਇੱਕ ਲੇਖ ਲਿਖਿਆ ਗਿਆ ਸੀ। ਟਿੱਪਣੀਆਂ ਵਿੱਚ ਮੈਨੂੰ WebAssembly ਵਿੱਚ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਰੀਮੇਕ ਕਰਨ ਦੀ ਸਲਾਹ ਦਿੱਤੀ ਗਈ ਸੀ, ਅਤੇ ਇੱਥੋਂ ਤੱਕ ਕਿ ਆਪਣੇ ਆਪ ਨੂੰ ਛੱਡ ਦਿੱਤਾ ਗਿਆ ਸੀ ਲਗਭਗ ਮੁਕੰਮਲ ਮੈਂ ਕਿਸੇ ਤਰ੍ਹਾਂ ਇਹ ਪ੍ਰੋਜੈਕਟ ਨਹੀਂ ਚਾਹੁੰਦਾ ਸੀ... ਕੰਮ ਚੱਲ ਰਿਹਾ ਸੀ, ਪਰ ਬਹੁਤ ਹੌਲੀ, ਅਤੇ ਹੁਣ, ਹਾਲ ਹੀ ਵਿੱਚ ਉਸ ਲੇਖ ਵਿੱਚ ਪ੍ਰਗਟ ਹੋਇਆ ਹੈ ਟਿੱਪਣੀ ਵਿਸ਼ੇ 'ਤੇ "ਤਾਂ ਇਹ ਸਭ ਕਿਵੇਂ ਖਤਮ ਹੋਇਆ?" ਮੇਰੇ ਵਿਸਤ੍ਰਿਤ ਜਵਾਬ ਦੇ ਜਵਾਬ ਵਿੱਚ, ਮੈਂ ਸੁਣਿਆ "ਇਹ ਇੱਕ ਲੇਖ ਵਰਗਾ ਲੱਗਦਾ ਹੈ." ਖੈਰ, ਜੇ ਤੁਸੀਂ ਕਰ ਸਕਦੇ ਹੋ, ਤਾਂ ਇੱਕ ਲੇਖ ਹੋਵੇਗਾ. ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਕਿਸੇ ਨੂੰ ਇਹ ਲਾਭਦਾਇਕ ਲੱਗੇ। ਇਸ ਤੋਂ ਪਾਠਕ QEMU ਕੋਡ ਜਨਰੇਸ਼ਨ ਬੈਕਐਂਡ ਦੇ ਡਿਜ਼ਾਈਨ ਬਾਰੇ ਕੁਝ ਤੱਥ ਸਿੱਖਣਗੇ, ਨਾਲ ਹੀ ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨ ਲਈ ਜਸਟ-ਇਨ-ਟਾਈਮ ਕੰਪਾਈਲਰ ਕਿਵੇਂ ਲਿਖਣਾ ਹੈ।

ਕੰਮ

ਕਿਉਂਕਿ ਮੈਂ ਪਹਿਲਾਂ ਹੀ ਜਾਣ ਲਿਆ ਸੀ ਕਿ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਲਈ QEMU ਨੂੰ ਕਿਵੇਂ "ਕਿਸੇ ਤਰ੍ਹਾਂ" ਪੋਰਟ ਕਰਨਾ ਹੈ, ਇਸ ਵਾਰ ਇਹ ਸਮਝਦਾਰੀ ਨਾਲ ਕਰਨ ਅਤੇ ਪੁਰਾਣੀਆਂ ਗਲਤੀਆਂ ਨੂੰ ਦੁਹਰਾਉਣ ਦਾ ਫੈਸਲਾ ਕੀਤਾ ਗਿਆ ਸੀ.

ਗਲਤੀ ਨੰਬਰ ਇੱਕ: ਪੁਆਇੰਟ ਰੀਲੀਜ਼ ਤੋਂ ਬ੍ਰਾਂਚ

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

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

ਗਲਤੀ ਨੰਬਰ ਦੋ: TLP ਵਿਧੀ

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

ਗਲਤੀ ਨੰਬਰ ਤਿੰਨ: ਫੋਰਡ ਨੂੰ ਜਾਣੇ ਬਿਨਾਂ ਪਾਣੀ ਵਿੱਚ ਜਾਣਾ

ਮੈਂ ਅਜੇ ਵੀ ਇਸ ਤੋਂ ਪੂਰੀ ਤਰ੍ਹਾਂ ਛੁਟਕਾਰਾ ਨਹੀਂ ਪਾਇਆ ਹੈ, ਪਰ ਹੁਣ ਮੈਂ ਘੱਟੋ-ਘੱਟ ਵਿਰੋਧ ਦੇ ਰਸਤੇ 'ਤੇ ਚੱਲਣ ਦਾ ਫੈਸਲਾ ਨਹੀਂ ਕੀਤਾ ਹੈ, ਅਤੇ ਇਸਨੂੰ "ਬਾਲਗ ਵਜੋਂ" ਕਰਨ ਦਾ ਫੈਸਲਾ ਕੀਤਾ ਹੈ, ਅਰਥਾਤ, ਸ਼ੁਰੂ ਤੋਂ ਮੇਰਾ TCG ਬੈਕਐਂਡ ਲਿਖੋ, ਤਾਂ ਕਿ ਨਾ ਬਾਅਦ ਵਿੱਚ ਕਹਿਣ ਲਈ, "ਹਾਂ, ਇਹ ਬੇਸ਼ਕ, ਹੌਲੀ ਹੌਲੀ ਹੈ, ਪਰ ਮੈਂ ਹਰ ਚੀਜ਼ ਨੂੰ ਕੰਟਰੋਲ ਨਹੀਂ ਕਰ ਸਕਦਾ - ਇਸ ਤਰ੍ਹਾਂ TCI ਲਿਖਿਆ ਗਿਆ ਹੈ..." ਇਸਤੋਂ ਇਲਾਵਾ, ਇਹ ਸ਼ੁਰੂ ਵਿੱਚ ਇੱਕ ਸਪੱਸ਼ਟ ਹੱਲ ਵਾਂਗ ਜਾਪਦਾ ਸੀ, ਕਿਉਂਕਿ ਮੈਂ ਬਾਈਨਰੀ ਕੋਡ ਤਿਆਰ ਕਰਦਾ ਹਾਂ. ਜਿਵੇਂ ਕਿ ਉਹ ਕਹਿੰਦੇ ਹਨ, "ਗੈਂਟ ਇਕੱਠੇ ਹੋਏу, ਪਰ ਉਹ ਇੱਕ ਨਹੀਂ”: ਕੋਡ, ਬੇਸ਼ੱਕ, ਬਾਈਨਰੀ ਹੈ, ਪਰ ਨਿਯੰਤਰਣ ਨੂੰ ਸਿਰਫ਼ ਇਸ ਵਿੱਚ ਤਬਦੀਲ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ - ਇਸ ਨੂੰ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਕੰਪਾਈਲੇਸ਼ਨ ਲਈ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਧੱਕਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ, ਨਤੀਜੇ ਵਜੋਂ JS ਸੰਸਾਰ ਤੋਂ ਇੱਕ ਖਾਸ ਵਸਤੂ, ਜਿਸਦੀ ਅਜੇ ਵੀ ਲੋੜ ਹੈ। ਕਿਤੇ ਬਚਾਇਆ ਜਾਵੇ। ਹਾਲਾਂਕਿ, ਸਧਾਰਣ RISC ਆਰਕੀਟੈਕਚਰ 'ਤੇ, ਜਿੱਥੋਂ ਤੱਕ ਮੈਂ ਸਮਝਦਾ ਹਾਂ, ਇੱਕ ਆਮ ਸਥਿਤੀ ਨੂੰ ਪੁਨਰਜਨਮ ਕੋਡ ਲਈ ਨਿਰਦੇਸ਼ ਕੈਸ਼ ਨੂੰ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਰੀਸੈਟ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ - ਜੇ ਇਹ ਉਹ ਨਹੀਂ ਹੈ ਜਿਸਦੀ ਸਾਨੂੰ ਲੋੜ ਹੈ, ਤਾਂ, ਕਿਸੇ ਵੀ ਸਥਿਤੀ ਵਿੱਚ, ਇਹ ਨੇੜੇ ਹੈ. ਇਸ ਤੋਂ ਇਲਾਵਾ, ਮੇਰੀ ਆਖਰੀ ਕੋਸ਼ਿਸ਼ ਤੋਂ, ਮੈਂ ਸਿੱਖਿਆ ਹੈ ਕਿ ਨਿਯੰਤਰਣ ਨੂੰ ਅਨੁਵਾਦ ਬਲਾਕ ਦੇ ਮੱਧ ਵਿੱਚ ਤਬਦੀਲ ਕੀਤਾ ਜਾਪਦਾ ਨਹੀਂ ਹੈ, ਇਸਲਈ ਸਾਨੂੰ ਅਸਲ ਵਿੱਚ ਕਿਸੇ ਵੀ ਔਫਸੈੱਟ ਤੋਂ ਵਿਆਖਿਆ ਕੀਤੇ ਬਾਈਟਕੋਡ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ, ਅਤੇ ਅਸੀਂ ਇਸਨੂੰ ਸਿਰਫ਼ ਟੀਬੀ 'ਤੇ ਫੰਕਸ਼ਨ ਤੋਂ ਤਿਆਰ ਕਰ ਸਕਦੇ ਹਾਂ। .

ਉਨ੍ਹਾਂ ਨੇ ਆ ਕੇ ਲੱਤ ਮਾਰੀ

ਹਾਲਾਂਕਿ ਮੈਂ ਜੁਲਾਈ ਵਿੱਚ ਕੋਡ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖਣਾ ਸ਼ੁਰੂ ਕੀਤਾ, ਇੱਕ ਜਾਦੂਈ ਕਿੱਕ ਨੇ ਧਿਆਨ ਨਹੀਂ ਦਿੱਤਾ: ਆਮ ਤੌਰ 'ਤੇ GitHub ਤੋਂ ਪੱਤਰ ਮੁੱਦਿਆਂ ਅਤੇ ਪੁੱਲ ਬੇਨਤੀਆਂ ਦੇ ਜਵਾਬਾਂ ਬਾਰੇ ਸੂਚਨਾਵਾਂ ਵਜੋਂ ਆਉਂਦੇ ਹਨ, ਪਰ ਇੱਥੇ, ਅਚਾਨਕ ਧਾਗੇ ਵਿੱਚ ਜ਼ਿਕਰ ਕਿਮੂ ਬੈਕਐਂਡ ਵਜੋਂ ਬਾਇਨੇਰੀਅਨ ਸੰਦਰਭ ਵਿੱਚ, "ਉਸਨੇ ਅਜਿਹਾ ਕੁਝ ਕੀਤਾ, ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਉਹ ਕੁਝ ਕਹੇ।" ਅਸੀਂ Emscripten ਦੀ ਸੰਬੰਧਿਤ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਨ ਬਾਰੇ ਗੱਲ ਕਰ ਰਹੇ ਸੀ ਬਾਇਨੇਰੀਅਨ WASM JIT ਬਣਾਉਣ ਲਈ. ਖੈਰ, ਮੈਂ ਕਿਹਾ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ਉੱਥੇ ਅਪਾਚੇ 2.0 ਲਾਇਸੰਸ ਹੈ, ਅਤੇ QEMU ਸਮੁੱਚੇ ਤੌਰ 'ਤੇ GPLv2 ਦੇ ਅਧੀਨ ਵੰਡਿਆ ਗਿਆ ਹੈ, ਅਤੇ ਉਹ ਬਹੁਤ ਅਨੁਕੂਲ ਨਹੀਂ ਹਨ। ਅਚਾਨਕ ਇਹ ਇੱਕ ਲਾਇਸੰਸ ਹੋ ਸਕਦਾ ਹੈ, ਜੋ ਕਿ ਬਾਹਰ ਬਦਲ ਦਿੱਤਾ ਇਸ ਨੂੰ ਕਿਸੇ ਤਰ੍ਹਾਂ ਠੀਕ ਕਰੋ (ਮੈਨੂੰ ਨਹੀਂ ਪਤਾ: ਹੋ ਸਕਦਾ ਹੈ ਇਸਨੂੰ ਬਦਲੋ, ਸ਼ਾਇਦ ਦੋਹਰਾ ਲਾਇਸੈਂਸ, ਸ਼ਾਇਦ ਕੁਝ ਹੋਰ...) ਇਸ ਨੇ, ਬੇਸ਼ੱਕ, ਮੈਨੂੰ ਖੁਸ਼ੀ ਦਿੱਤੀ, ਕਿਉਂਕਿ ਉਸ ਸਮੇਂ ਤੱਕ ਮੈਂ ਪਹਿਲਾਂ ਹੀ ਨੇੜਿਓਂ ਦੇਖਿਆ ਸੀ ਬਾਈਨਰੀ ਫਾਰਮੈਟ WebAssembly, ਅਤੇ ਮੈਂ ਕਿਸੇ ਤਰ੍ਹਾਂ ਉਦਾਸ ਅਤੇ ਸਮਝ ਤੋਂ ਬਾਹਰ ਸੀ। ਇੱਥੇ ਇੱਕ ਲਾਇਬ੍ਰੇਰੀ ਵੀ ਸੀ ਜੋ ਪਰਿਵਰਤਨ ਗ੍ਰਾਫ ਦੇ ਨਾਲ ਬੁਨਿਆਦੀ ਬਲਾਕਾਂ ਨੂੰ ਖਾ ਜਾਂਦੀ ਸੀ, ਬਾਈਟਕੋਡ ਤਿਆਰ ਕਰਦੀ ਸੀ, ਅਤੇ ਲੋੜ ਪੈਣ 'ਤੇ ਇਸਨੂੰ ਦੁਭਾਸ਼ੀਏ ਵਿੱਚ ਵੀ ਚਲਾਉਂਦੀ ਸੀ।

ਫਿਰ ਹੋਰ ਸੀ ਇਕ ਚਿੱਠੀ QEMU ਮੇਲਿੰਗ ਲਿਸਟ 'ਤੇ, ਪਰ ਇਹ ਇਸ ਸਵਾਲ ਬਾਰੇ ਵਧੇਰੇ ਹੈ, "ਕਿਸੇ ਵੀ ਇਸਦੀ ਲੋੜ ਹੈ?" ਅਤੇ ਇਹ ਹੈ ਅਚਾਨਕ, ਇਹ ਜ਼ਰੂਰੀ ਸੀ ਬਾਹਰ ਬਦਲ ਦਿੱਤਾ. ਘੱਟੋ-ਘੱਟ, ਤੁਸੀਂ ਵਰਤੋਂ ਦੀਆਂ ਹੇਠ ਲਿਖੀਆਂ ਸੰਭਾਵਨਾਵਾਂ ਨੂੰ ਇਕੱਠਾ ਕਰ ਸਕਦੇ ਹੋ, ਜੇਕਰ ਇਹ ਘੱਟ ਜਾਂ ਤੇਜ਼ੀ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ:

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

ਬ੍ਰਾਊਜ਼ਰ ਰਨਟਾਈਮ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ

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

ਦੂਜੀ ਵਿਸ਼ੇਸ਼ਤਾ ਸਟੈਕ ਦੇ ਨਾਲ ਹੇਠਲੇ-ਪੱਧਰ ਦੀ ਹੇਰਾਫੇਰੀ ਦੀ ਅਸੰਭਵਤਾ ਹੈ: ਤੁਸੀਂ ਬਸ ਨਹੀਂ ਲੈ ਸਕਦੇ, ਮੌਜੂਦਾ ਸੰਦਰਭ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਇੱਕ ਨਵੇਂ ਸਟੈਕ ਨਾਲ ਇੱਕ ਨਵੇਂ 'ਤੇ ਸਵਿਚ ਕਰ ਸਕਦੇ ਹੋ। ਕਾਲ ਸਟੈਕ ਦਾ ਪ੍ਰਬੰਧਨ JS ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਦੁਆਰਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਜਾਪਦਾ ਹੈ, ਸਮੱਸਿਆ ਕੀ ਹੈ, ਕਿਉਂਕਿ ਅਸੀਂ ਅਜੇ ਵੀ ਪੁਰਾਣੇ ਵਹਾਅ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਹੱਥੀਂ ਪ੍ਰਬੰਧਨ ਕਰਨ ਦਾ ਫੈਸਲਾ ਕੀਤਾ ਹੈ? ਤੱਥ ਇਹ ਹੈ ਕਿ QEMU ਵਿੱਚ ਬਲਾਕ I/O ਨੂੰ ਕੋਰਉਟਾਈਨ ਦੁਆਰਾ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਤੇ ਇਹ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ ਘੱਟ-ਪੱਧਰੀ ਸਟੈਕ ਹੇਰਾਫੇਰੀ ਕੰਮ ਵਿੱਚ ਆਵੇਗੀ। ਖੁਸ਼ਕਿਸਮਤੀ ਨਾਲ, Emscipten ਵਿੱਚ ਪਹਿਲਾਂ ਹੀ ਅਸਿੰਕਰੋਨਸ ਓਪਰੇਸ਼ਨਾਂ ਲਈ ਇੱਕ ਵਿਧੀ ਹੈ, ਇੱਥੋਂ ਤੱਕ ਕਿ ਦੋ: ਅਸਿੰਸੀਫਾਈ и ਐਂਟਰਪ੍ਰੇਟਰ. ਪਹਿਲਾ ਇੱਕ ਤਿਆਰ ਕੀਤੇ JavaScript ਕੋਡ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਬਲੋਟ ਦੁਆਰਾ ਕੰਮ ਕਰਦਾ ਹੈ ਅਤੇ ਹੁਣ ਸਮਰਥਿਤ ਨਹੀਂ ਹੈ। ਦੂਜਾ ਮੌਜੂਦਾ "ਸਹੀ ਤਰੀਕਾ" ਹੈ ਅਤੇ ਮੂਲ ਦੁਭਾਸ਼ੀਏ ਲਈ ਬਾਈਟਕੋਡ ਜਨਰੇਸ਼ਨ ਦੁਆਰਾ ਕੰਮ ਕਰਦਾ ਹੈ। ਇਹ, ਬੇਸ਼ਕ, ਹੌਲੀ ਹੌਲੀ ਕੰਮ ਕਰਦਾ ਹੈ, ਪਰ ਇਹ ਕੋਡ ਨੂੰ ਫੁੱਲਦਾ ਨਹੀਂ ਹੈ. ਇਹ ਸੱਚ ਹੈ ਕਿ, ਇਸ ਵਿਧੀ ਲਈ ਕੋਰਉਟੀਨ ਲਈ ਸਮਰਥਨ ਸੁਤੰਤਰ ਤੌਰ 'ਤੇ ਯੋਗਦਾਨ ਪਾਉਣਾ ਪੈਂਦਾ ਸੀ (ਇੱਥੇ ਪਹਿਲਾਂ ਹੀ ਅਸਿੰਸੀਫਾਈ ਲਈ ਕੋਰੋਟੀਨ ਲਿਖੀਆਂ ਗਈਆਂ ਸਨ ਅਤੇ ਐਮਟਰਪ੍ਰੀਟਰ ਲਈ ਲਗਭਗ ਇੱਕੋ API ਨੂੰ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਸੀ, ਤੁਹਾਨੂੰ ਉਹਨਾਂ ਨੂੰ ਕਨੈਕਟ ਕਰਨ ਦੀ ਲੋੜ ਸੀ)।

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

• ਵਿਆਖਿਆ ਕੀਤੀ ਬਲਾਕ I/O. ਖੈਰ, ਕੀ ਤੁਸੀਂ ਅਸਲ ਵਿੱਚ ਨੇਟਿਵ ਪ੍ਰਦਰਸ਼ਨ ਦੇ ਨਾਲ ਨਕਲ ਕੀਤੇ NVMe ਦੀ ਉਮੀਦ ਕੀਤੀ ਸੀ? 🙂
• ਸਥਿਰ ਤੌਰ 'ਤੇ ਕੰਪਾਇਲ ਕੀਤਾ ਮੁੱਖ QEMU ਕੋਡ (ਅਨੁਵਾਦਕ, ਹੋਰ ਇਮੂਲੇਟਿਡ ਡਿਵਾਈਸਾਂ, ਆਦਿ)
• ਗਤੀਸ਼ੀਲ ਤੌਰ 'ਤੇ WASM ਵਿੱਚ ਗਿਸਟ ਕੋਡ ਨੂੰ ਕੰਪਾਇਲ ਕੀਤਾ

QEMU ਸਰੋਤਾਂ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ

ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਸ਼ਾਇਦ ਪਹਿਲਾਂ ਹੀ ਅੰਦਾਜ਼ਾ ਲਗਾ ਲਿਆ ਹੈ, ਗੈਸਟ ਆਰਕੀਟੈਕਚਰ ਦੀ ਨਕਲ ਕਰਨ ਲਈ ਕੋਡ ਅਤੇ ਹੋਸਟ ਮਸ਼ੀਨ ਨਿਰਦੇਸ਼ ਤਿਆਰ ਕਰਨ ਲਈ ਕੋਡ QEMU ਵਿੱਚ ਵੱਖ ਕੀਤੇ ਗਏ ਹਨ। ਵਾਸਤਵ ਵਿੱਚ, ਇਹ ਥੋੜਾ ਜਿਹਾ ਗੁੰਝਲਦਾਰ ਵੀ ਹੈ:

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

ਤਰੀਕੇ ਨਾਲ, ਕੀ ਤੁਸੀਂ ਜਾਣਦੇ ਹੋ: QEMU ਨਾ ਸਿਰਫ਼ ਪੂਰੇ ਕੰਪਿਊਟਰ ਦੀ ਨਕਲ ਕਰ ਸਕਦਾ ਹੈ, ਸਗੋਂ ਹੋਸਟ ਕਰਨਲ ਵਿੱਚ ਇੱਕ ਵੱਖਰੀ ਉਪਭੋਗਤਾ ਪ੍ਰਕਿਰਿਆ ਲਈ ਪ੍ਰੋਸੈਸਰ ਵੀ ਤਿਆਰ ਕਰ ਸਕਦਾ ਹੈ, ਜਿਸਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਉਦਾਹਰਨ ਲਈ, ਬਾਈਨਰੀ ਇੰਸਟਰੂਮੈਂਟੇਸ਼ਨ ਲਈ AFL ਫਜ਼ਰ ਦੁਆਰਾ। ਸ਼ਾਇਦ ਕੋਈ JS ਨੂੰ QEMU ਦੇ ਸੰਚਾਲਨ ਦੇ ਇਸ ਮੋਡ ਨੂੰ ਪੋਰਟ ਕਰਨਾ ਚਾਹੇਗਾ? 😉

ਜ਼ਿਆਦਾਤਰ ਲੰਬੇ ਸਮੇਂ ਤੋਂ ਚੱਲ ਰਹੇ ਮੁਫਤ ਸੌਫਟਵੇਅਰ ਦੀ ਤਰ੍ਹਾਂ, QEMU ਕਾਲ ਦੁਆਰਾ ਬਣਾਇਆ ਗਿਆ ਹੈ configure и make. ਮੰਨ ਲਓ ਕਿ ਤੁਸੀਂ ਕੁਝ ਜੋੜਨ ਦਾ ਫੈਸਲਾ ਕਰਦੇ ਹੋ: ਇੱਕ TCG ਬੈਕਐਂਡ, ਥ੍ਰੈਡ ਲਾਗੂ ਕਰਨਾ, ਕੁਝ ਹੋਰ। Autoconf ਨਾਲ ਸੰਚਾਰ ਕਰਨ ਦੀ ਸੰਭਾਵਨਾ 'ਤੇ ਖੁਸ਼/ਡਰਾਉਣ (ਉਚਿਤ ਤੌਰ 'ਤੇ ਰੇਖਾਂਕਿਤ) ਹੋਣ ਦੀ ਕਾਹਲੀ ਨਾ ਕਰੋ - ਅਸਲ ਵਿੱਚ, configure QEMU's ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਸਵੈ-ਲਿਖਤ ਹੈ ਅਤੇ ਕਿਸੇ ਵੀ ਚੀਜ਼ ਤੋਂ ਤਿਆਰ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ।

ਵੈੱਬਅਸੈਪਲੇਸ

ਤਾਂ ਇਸ ਚੀਜ਼ ਨੂੰ ਕੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ WebAssembly (ਉਰਫ਼ WASM)? ਇਹ Asm.js ਦਾ ਬਦਲ ਹੈ, ਹੁਣ ਵੈਧ JavaScript ਕੋਡ ਹੋਣ ਦਾ ਢੌਂਗ ਨਹੀਂ ਕਰ ਰਿਹਾ। ਇਸਦੇ ਉਲਟ, ਇਹ ਪੂਰੀ ਤਰ੍ਹਾਂ ਬਾਈਨਰੀ ਅਤੇ ਅਨੁਕੂਲਿਤ ਹੈ, ਅਤੇ ਇੱਥੋਂ ਤੱਕ ਕਿ ਇਸ ਵਿੱਚ ਇੱਕ ਪੂਰਨ ਅੰਕ ਲਿਖਣਾ ਵੀ ਬਹੁਤ ਸੌਖਾ ਨਹੀਂ ਹੈ: ਸੰਖੇਪਤਾ ਲਈ, ਇਹ ਫਾਰਮੈਟ ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ LEB128.

ਤੁਸੀਂ Asm.js ਲਈ ਰੀਲੂਪਿੰਗ ਐਲਗੋਰਿਦਮ ਬਾਰੇ ਸੁਣਿਆ ਹੋਵੇਗਾ - ਇਹ "ਉੱਚ-ਪੱਧਰੀ" ਪ੍ਰਵਾਹ ਨਿਯੰਤਰਣ ਨਿਰਦੇਸ਼ਾਂ ਦੀ ਬਹਾਲੀ ਹੈ (ਜੋ ਕਿ, ਜੇ-ਤਾਂ-ਹੋਰ, ਲੂਪਸ, ਆਦਿ), ਜਿਸ ਲਈ JS ਇੰਜਣਾਂ ਨੂੰ ਡਿਜ਼ਾਈਨ ਕੀਤਾ ਗਿਆ ਹੈ, ਤੋਂ ਘੱਟ-ਪੱਧਰੀ LLVM IR, ਪ੍ਰੋਸੈਸਰ ਦੁਆਰਾ ਚਲਾਏ ਗਏ ਮਸ਼ੀਨ ਕੋਡ ਦੇ ਨੇੜੇ। ਕੁਦਰਤੀ ਤੌਰ 'ਤੇ, QEMU ਦੀ ਵਿਚਕਾਰਲੀ ਨੁਮਾਇੰਦਗੀ ਦੂਜੇ ਦੇ ਨੇੜੇ ਹੈ. ਅਜਿਹਾ ਲਗਦਾ ਹੈ ਕਿ ਇਹ ਇੱਥੇ ਹੈ, ਬਾਈਟਕੋਡ, ਤਸੀਹੇ ਦਾ ਅੰਤ... ਅਤੇ ਫਿਰ ਇੱਥੇ ਬਲਾਕ ਹਨ, ਜੇ-ਤਾਂ-ਹੋਰ ਅਤੇ ਲੂਪਸ!..

ਅਤੇ ਇਹ ਇਕ ਹੋਰ ਕਾਰਨ ਹੈ ਕਿ ਬਾਇਨੇਰੀਅਨ ਲਾਭਦਾਇਕ ਹੈ: ਇਹ ਕੁਦਰਤੀ ਤੌਰ 'ਤੇ WASM ਵਿੱਚ ਸਟੋਰ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਉੱਚ-ਪੱਧਰੀ ਬਲਾਕਾਂ ਨੂੰ ਸਵੀਕਾਰ ਕਰ ਸਕਦਾ ਹੈ। ਪਰ ਇਹ ਮੂਲ ਬਲਾਕਾਂ ਦੇ ਗ੍ਰਾਫ ਅਤੇ ਉਹਨਾਂ ਵਿਚਕਾਰ ਤਬਦੀਲੀਆਂ ਤੋਂ ਕੋਡ ਵੀ ਪੈਦਾ ਕਰ ਸਕਦਾ ਹੈ। ਖੈਰ, ਮੈਂ ਪਹਿਲਾਂ ਹੀ ਕਿਹਾ ਹੈ ਕਿ ਇਹ ਸੁਵਿਧਾਜਨਕ C/C++ API ਦੇ ਪਿੱਛੇ WebAssembly ਸਟੋਰੇਜ ਫਾਰਮੈਟ ਨੂੰ ਲੁਕਾਉਂਦਾ ਹੈ।

TCG (ਛੋਟੇ ਕੋਡ ਜਨਰੇਟਰ)

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

QEMU ਵਿੱਚ ਇੱਕ ਨਵਾਂ TCG ਬੈਕਐਂਡ ਜੋੜਨ ਲਈ, ਤੁਹਾਨੂੰ ਇੱਕ ਸਬ-ਡਾਇਰੈਕਟਰੀ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ tcg/<имя архитектуры> (ਇਸ ਮਾਮਲੇ ਵਿੱਚ, tcg/binaryen), ਅਤੇ ਇਸ ਵਿੱਚ ਦੋ ਫਾਈਲਾਂ ਹਨ: tcg-target.h и tcg-target.inc.c и ਰਜਿਸਟਰ ਇਹ ਸਭ ਇਸ ਬਾਰੇ ਹੈ configure. ਤੁਸੀਂ ਉੱਥੇ ਹੋਰ ਫਾਈਲਾਂ ਰੱਖ ਸਕਦੇ ਹੋ, ਪਰ, ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਇਹਨਾਂ ਦੋਵਾਂ ਦੇ ਨਾਵਾਂ ਤੋਂ ਅੰਦਾਜ਼ਾ ਲਗਾ ਸਕਦੇ ਹੋ, ਉਹ ਦੋਵੇਂ ਕਿਤੇ ਸ਼ਾਮਲ ਕੀਤੇ ਜਾਣਗੇ: ਇੱਕ ਨਿਯਮਤ ਸਿਰਲੇਖ ਫਾਈਲ ਦੇ ਰੂਪ ਵਿੱਚ (ਇਸ ਵਿੱਚ ਸ਼ਾਮਲ ਹੈ tcg/tcg.h, ਅਤੇ ਇਹ ਡਾਇਰੈਕਟਰੀਆਂ ਵਿੱਚ ਪਹਿਲਾਂ ਤੋਂ ਹੀ ਹੋਰ ਫਾਈਲਾਂ ਵਿੱਚ ਹੈ tcg, accel ਅਤੇ ਨਾ ਸਿਰਫ਼), ਦੂਜਾ - ਸਿਰਫ਼ ਇੱਕ ਕੋਡ ਸਨਿੱਪਟ ਦੇ ਰੂਪ ਵਿੱਚ tcg/tcg.c, ਪਰ ਇਸਦੀ ਇਸਦੇ ਸਥਿਰ ਫੰਕਸ਼ਨਾਂ ਤੱਕ ਪਹੁੰਚ ਹੈ।

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

ਫਾਇਲ tcg-target.h ਫਾਰਮ ਵਿੱਚ ਮੁੱਖ ਤੌਰ 'ਤੇ ਸੈਟਿੰਗਾਂ ਸ਼ਾਮਲ ਹਨ #define-s:

• ਟਾਰਗੇਟ ਆਰਕੀਟੈਕਚਰ 'ਤੇ ਕਿੰਨੇ ਰਜਿਸਟਰ ਹਨ ਅਤੇ ਕਿੰਨੀ ਚੌੜਾਈ ਹੈ (ਸਾਡੇ ਕੋਲ ਜਿੰਨੇ ਅਸੀਂ ਚਾਹੁੰਦੇ ਹਾਂ, ਜਿੰਨੇ ਅਸੀਂ ਚਾਹੁੰਦੇ ਹਾਂ - ਸਵਾਲ ਇਹ ਹੈ ਕਿ "ਪੂਰੀ ਤਰ੍ਹਾਂ ਨਿਸ਼ਾਨਾ" ਆਰਕੀਟੈਕਚਰ 'ਤੇ ਬ੍ਰਾਊਜ਼ਰ ਦੁਆਰਾ ਵਧੇਰੇ ਕੁਸ਼ਲ ਕੋਡ ਵਿੱਚ ਕੀ ਤਿਆਰ ਕੀਤਾ ਜਾਵੇਗਾ। ...)
• ਹੋਸਟ ਨਿਰਦੇਸ਼ਾਂ ਦੀ ਇਕਸਾਰਤਾ: x86 'ਤੇ, ਅਤੇ ਇੱਥੋਂ ਤੱਕ ਕਿ TCI ਵਿੱਚ ਵੀ, ਨਿਰਦੇਸ਼ ਬਿਲਕੁਲ ਵੀ ਇਕਸਾਰ ਨਹੀਂ ਹਨ, ਪਰ ਮੈਂ ਕੋਡ ਬਫਰ ਵਿੱਚ ਨਿਰਦੇਸ਼ਾਂ ਨੂੰ ਨਹੀਂ, ਬਲਕਿ ਬਾਇਨੇਰੀਅਨ ਲਾਇਬ੍ਰੇਰੀ ਢਾਂਚੇ ਵੱਲ ਪੁਆਇੰਟਰ ਲਗਾਉਣ ਜਾ ਰਿਹਾ ਹਾਂ, ਇਸ ਲਈ ਮੈਂ ਕਹਾਂਗਾ: 4 ਬਾਈਟ
• ਬੈਕਐਂਡ ਕਿਹੜੀਆਂ ਵਿਕਲਪਿਕ ਹਿਦਾਇਤਾਂ ਤਿਆਰ ਕਰ ਸਕਦਾ ਹੈ - ਅਸੀਂ ਉਹ ਸਭ ਕੁਝ ਸ਼ਾਮਲ ਕਰਦੇ ਹਾਂ ਜੋ ਅਸੀਂ ਬਾਇਨਰੀਨ ਵਿੱਚ ਲੱਭਦੇ ਹਾਂ, ਐਕਸਲੇਟਰ ਨੂੰ ਬਾਕੀ ਨੂੰ ਸਧਾਰਨ ਵਿੱਚ ਵੰਡਣ ਦਿਓ
• ਬੈਕਐਂਡ ਦੁਆਰਾ ਬੇਨਤੀ ਕੀਤੀ TLB ਕੈਸ਼ ਦਾ ਅੰਦਾਜ਼ਨ ਆਕਾਰ ਕੀ ਹੈ। ਤੱਥ ਇਹ ਹੈ ਕਿ QEMU ਵਿੱਚ ਸਭ ਕੁਝ ਗੰਭੀਰ ਹੈ: ਹਾਲਾਂਕਿ ਇੱਥੇ ਸਹਾਇਕ ਫੰਕਸ਼ਨ ਹਨ ਜੋ ਲੋਡ/ਸਟੋਰ ਕਰਦੇ ਹਨ ਗੈਸਟ MMU (ਅਸੀਂ ਹੁਣ ਇਸ ਤੋਂ ਬਿਨਾਂ ਕਿੱਥੇ ਹੋਵਾਂਗੇ?) ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਦੇ ਹੋਏ, ਉਹ ਆਪਣੇ ਅਨੁਵਾਦ ਕੈਸ਼ ਨੂੰ ਇੱਕ ਢਾਂਚੇ ਦੇ ਰੂਪ ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਕਰਦੇ ਹਨ, ਜਿਸਦੀ ਪ੍ਰੋਸੈਸਿੰਗ ਸਿੱਧੇ ਪ੍ਰਸਾਰਣ ਬਲਾਕਾਂ ਵਿੱਚ ਏਮਬੇਡ ਕਰਨ ਲਈ ਸੁਵਿਧਾਜਨਕ ਹੈ। ਸਵਾਲ ਇਹ ਹੈ ਕਿ, ਇਸ ਢਾਂਚੇ ਵਿੱਚ ਕਿਹੜੀ ਔਫਸੈੱਟ ਕਮਾਂਡਾਂ ਦੇ ਇੱਕ ਛੋਟੇ ਅਤੇ ਤੇਜ਼ ਕ੍ਰਮ ਦੁਆਰਾ ਸਭ ਤੋਂ ਕੁਸ਼ਲਤਾ ਨਾਲ ਪ੍ਰਕਿਰਿਆ ਕੀਤੀ ਜਾਂਦੀ ਹੈ?
• ਇੱਥੇ ਤੁਸੀਂ ਇੱਕ ਜਾਂ ਦੋ ਰਿਜ਼ਰਵਡ ਰਜਿਸਟਰਾਂ ਦੇ ਉਦੇਸ਼ ਨੂੰ ਬਦਲ ਸਕਦੇ ਹੋ, ਇੱਕ ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਟੀਬੀ ਨੂੰ ਕਾਲ ਕਰਨ ਨੂੰ ਸਮਰੱਥ ਬਣਾ ਸਕਦੇ ਹੋ ਅਤੇ ਵਿਕਲਪਿਕ ਤੌਰ 'ਤੇ ਕੁਝ ਛੋਟੇ ਦਾ ਵਰਣਨ ਕਰ ਸਕਦੇ ਹੋ। inline- ਫੰਕਸ਼ਨ ਵਰਗੇ flush_icache_range (ਪਰ ਇਹ ਸਾਡਾ ਮਾਮਲਾ ਨਹੀਂ ਹੈ)

ਫਾਇਲ tcg-target.inc.c, ਬੇਸ਼ੱਕ, ਆਮ ਤੌਰ 'ਤੇ ਆਕਾਰ ਵਿੱਚ ਬਹੁਤ ਵੱਡਾ ਹੁੰਦਾ ਹੈ ਅਤੇ ਇਸ ਵਿੱਚ ਕਈ ਲਾਜ਼ਮੀ ਫੰਕਸ਼ਨ ਹੁੰਦੇ ਹਨ:

• ਸ਼ੁਰੂਆਤ, ਜਿਸ 'ਤੇ ਪਾਬੰਦੀਆਂ ਸ਼ਾਮਲ ਹਨ ਕਿ ਕਿਹੜੇ ਨਿਰਦੇਸ਼ਾਂ 'ਤੇ ਕੰਮ ਕਰ ਸਕਦੇ ਹਨ। ਕਿਸੇ ਹੋਰ ਬੈਕਐਂਡ ਤੋਂ ਮੇਰੇ ਦੁਆਰਾ ਬੇਲੋੜੀ ਨਕਲ ਕੀਤੀ ਗਈ
• ਫੰਕਸ਼ਨ ਜੋ ਇੱਕ ਅੰਦਰੂਨੀ ਬਾਈਟਕੋਡ ਨਿਰਦੇਸ਼ ਲੈਂਦਾ ਹੈ
• ਤੁਸੀਂ ਇੱਥੇ ਸਹਾਇਕ ਫੰਕਸ਼ਨ ਵੀ ਪਾ ਸਕਦੇ ਹੋ, ਅਤੇ ਤੁਸੀਂ ਸਟੈਟਿਕ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ tcg/tcg.c

ਆਪਣੇ ਲਈ, ਮੈਂ ਹੇਠ ਲਿਖੀ ਰਣਨੀਤੀ ਚੁਣੀ: ਅਗਲੇ ਅਨੁਵਾਦ ਬਲਾਕ ਦੇ ਪਹਿਲੇ ਸ਼ਬਦਾਂ ਵਿੱਚ, ਮੈਂ ਚਾਰ ਪੁਆਇੰਟਰ ਲਿਖੇ: ਇੱਕ ਸ਼ੁਰੂਆਤੀ ਚਿੰਨ੍ਹ (ਆਸੇ-ਪਾਸੇ ਵਿੱਚ ਇੱਕ ਖਾਸ ਮੁੱਲ 0xFFFFFFFF, ਜੋ ਕਿ ਟੀਬੀ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ), ਸੰਦਰਭ, ਤਿਆਰ ਮੋਡੀਊਲ, ਅਤੇ ਡੀਬੱਗਿੰਗ ਲਈ ਮੈਜਿਕ ਨੰਬਰ। ਪਹਿਲਾਂ ਤਾਂ ਨਿਸ਼ਾਨ ਲਗਾਇਆ ਗਿਆ ਸੀ 0xFFFFFFFF - nਕਿੱਥੇ n - ਇੱਕ ਛੋਟੀ ਸਕਾਰਾਤਮਕ ਸੰਖਿਆ, ਅਤੇ ਹਰ ਵਾਰ ਜਦੋਂ ਇਸਨੂੰ ਦੁਭਾਸ਼ੀਏ ਦੁਆਰਾ ਚਲਾਇਆ ਗਿਆ ਤਾਂ ਇਹ 1 ਦੁਆਰਾ ਵਧਿਆ। ਜਦੋਂ ਇਹ ਪਹੁੰਚ ਗਿਆ 0xFFFFFFFE, ਸੰਕਲਨ ਹੋਇਆ, ਮੋਡੀਊਲ ਫੰਕਸ਼ਨ ਟੇਬਲ ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਕੀਤਾ ਗਿਆ ਸੀ, ਇੱਕ ਛੋਟੇ "ਲਾਂਚਰ" ਵਿੱਚ ਆਯਾਤ ਕੀਤਾ ਗਿਆ ਸੀ, ਜਿਸ ਵਿੱਚ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਚਲਿਆ ਗਿਆ ਸੀ tcg_qemu_tb_exec, ਅਤੇ ਮੋਡੀਊਲ ਨੂੰ QEMU ਮੈਮੋਰੀ ਤੋਂ ਹਟਾ ਦਿੱਤਾ ਗਿਆ ਸੀ।

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

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

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

Binaryen ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ

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

ਫੰਕਸ਼ਨਾਂ ਵਿੱਚ ਲੋਕਲ ਵੇਰੀਏਬਲ ਵੀ ਹੁੰਦੇ ਹਨ, ਜ਼ੀਰੋ ਤੋਂ ਨੰਬਰ ਦਿੱਤੇ, ਕਿਸਮ ਦੇ: int32 / int64 / ਫਲੋਟ / ਡਬਲ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਪਹਿਲੇ n ਲੋਕਲ ਵੇਰੀਏਬਲ ਫੰਕਸ਼ਨ ਨੂੰ ਪਾਸ ਕੀਤੇ ਗਏ ਆਰਗੂਮੈਂਟ ਹਨ। ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਹਾਲਾਂਕਿ ਇੱਥੇ ਹਰ ਚੀਜ਼ ਨਿਯੰਤਰਣ ਪ੍ਰਵਾਹ ਦੇ ਰੂਪ ਵਿੱਚ ਪੂਰੀ ਤਰ੍ਹਾਂ ਘੱਟ-ਪੱਧਰ ਦੀ ਨਹੀਂ ਹੈ, ਪੂਰਨ ਅੰਕ ਅਜੇ ਵੀ "ਹਸਤਾਖਰਿਤ/ਹਸਤਾਖਰਿਤ" ਵਿਸ਼ੇਸ਼ਤਾ ਨਹੀਂ ਰੱਖਦੇ ਹਨ: ਸੰਖਿਆ ਕਿਵੇਂ ਵਿਵਹਾਰ ਕਰਦੀ ਹੈ ਓਪਰੇਸ਼ਨ ਕੋਡ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ।

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

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

ਇਸ ਲਈ ਤੁਹਾਨੂੰ ਲੋੜੀਂਦਾ ਕੋਡ ਬਣਾਉਣ ਲਈ

// настроить глобальные параметры (можно поменять потом)
BinaryenSetAPITracing(0);

BinaryenSetOptimizeLevel(3);
BinaryenSetShrinkLevel(2);

// создать модуль
BinaryenModuleRef MODULE = BinaryenModuleCreate();

// описать типы функций (как создаваемых, так и вызываемых)
helper_type  BinaryenAddFunctionType(MODULE, "helper-func", BinaryenTypeInt32(), int32_helper_args, ARRAY_SIZE(int32_helper_args));
// (int23_helper_args приоб^Wсоздаются отдельно)

// сконструировать супер-мега выражение
// ... ну тут уж вы как-нибудь сами :)

// потом создать функцию
BinaryenAddFunction(MODULE, "tb_fun", tb_func_type, func_locals, FUNC_LOCALS_COUNT, expr);
BinaryenAddFunctionExport(MODULE, "tb_fun", "tb_fun");
...
BinaryenSetMemory(MODULE, (1 << 15) - 1, -1, NULL, NULL, NULL, NULL, NULL, 0, 0);
BinaryenAddMemoryImport(MODULE, NULL, "env", "memory", 0);
BinaryenAddTableImport(MODULE, NULL, "env", "tb_funcs");

// запросить валидацию и оптимизацию при желании
assert (BinaryenModuleValidate(MODULE));
BinaryenModuleOptimize(MODULE);

... ਜੇਕਰ ਮੈਂ ਕੁਝ ਭੁੱਲ ਗਿਆ ਹਾਂ, ਮਾਫ ਕਰਨਾ, ਇਹ ਸਿਰਫ ਸਕੇਲ ਨੂੰ ਦਰਸਾਉਣ ਲਈ ਹੈ, ਅਤੇ ਵੇਰਵੇ ਦਸਤਾਵੇਜ਼ਾਂ ਵਿੱਚ ਹਨ।

ਅਤੇ ਹੁਣ ਕਰੈਕ-ਫੈਕਸ-ਪੈਕਸ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ, ਕੁਝ ਇਸ ਤਰ੍ਹਾਂ:

static char buf[1 << 20];
BinaryenModuleOptimize(MODULE);
BinaryenSetMemory(MODULE, 0, -1, NULL, NULL, NULL, NULL, NULL, 0, 0);
int sz = BinaryenModuleWrite(MODULE, buf, sizeof(buf));
BinaryenModuleDispose(MODULE);
EM_ASM({
  var module = new WebAssembly.Module(new Uint8Array(wasmMemory.buffer, $0, $1));
  var fptr = $2;
  var instance = new WebAssembly.Instance(module, {
      'env': {
          'memory': wasmMemory,
          // ...
      }
  );
  // и вот уже у вас есть instance!
}, buf, sz);

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

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

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

ਅੰਤ ਵਿੱਚ ਇੱਕ ਬੁਝਾਰਤ: ਤੁਸੀਂ ਇੱਕ 32-ਬਿੱਟ ਆਰਕੀਟੈਕਚਰ 'ਤੇ ਇੱਕ ਬਾਈਨਰੀ ਕੰਪਾਈਲ ਕੀਤੀ ਹੈ, ਪਰ ਕੋਡ, ਮੈਮੋਰੀ ਓਪਰੇਸ਼ਨਾਂ ਰਾਹੀਂ, ਬਾਇਨਰੀਨ ਤੋਂ, ਕਿਤੇ ਸਟੈਕ 'ਤੇ, ਜਾਂ 2-ਬਿੱਟ ਐਡਰੈੱਸ ਸਪੇਸ ਦੇ ਉੱਪਰਲੇ 32 GB ਵਿੱਚ ਕਿਤੇ ਹੋਰ ਚੜ੍ਹਦਾ ਹੈ। ਸਮੱਸਿਆ ਇਹ ਹੈ ਕਿ ਬਾਇਨਰੀਅਨ ਦੇ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਤੋਂ ਇਹ ਬਹੁਤ ਵੱਡੇ ਨਤੀਜੇ ਵਾਲੇ ਪਤੇ ਤੱਕ ਪਹੁੰਚ ਕਰ ਰਿਹਾ ਹੈ। ਇਸ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਕਿਵੇਂ ਜਾਣਾ ਹੈ?

ਐਡਮਿਨ ਦੇ ਤਰੀਕੇ ਨਾਲ

ਮੈਂ ਇਸਦੀ ਜਾਂਚ ਨਹੀਂ ਕੀਤੀ, ਪਰ ਮੇਰਾ ਪਹਿਲਾ ਵਿਚਾਰ ਸੀ "ਜੇ ਮੈਂ 32-ਬਿੱਟ ਲੀਨਕਸ ਨੂੰ ਸਥਾਪਿਤ ਕੀਤਾ ਤਾਂ ਕੀ ਹੋਵੇਗਾ?" ਫਿਰ ਐਡਰੈੱਸ ਸਪੇਸ ਦਾ ਉਪਰਲਾ ਹਿੱਸਾ ਕਰਨਲ ਦੁਆਰਾ ਕਬਜ਼ਾ ਕਰ ਲਿਆ ਜਾਵੇਗਾ। ਸਿਰਫ ਸਵਾਲ ਇਹ ਹੈ ਕਿ ਕਿੰਨਾ ਕੁ ਕਬਜ਼ਾ ਕੀਤਾ ਜਾਵੇਗਾ: 1 ਜਾਂ 2 ਜੀ.ਬੀ.

ਪ੍ਰੋਗਰਾਮਰ ਦੇ ਤਰੀਕੇ ਨਾਲ (ਪ੍ਰੈਕਟੀਸ਼ਨਰਾਂ ਲਈ ਵਿਕਲਪ)

ਆਉ ਐਡਰੈੱਸ ਸਪੇਸ ਦੇ ਸਿਖਰ 'ਤੇ ਇੱਕ ਬੁਲਬੁਲਾ ਉਡਾਈਏ। ਮੈਂ ਖੁਦ ਨਹੀਂ ਸਮਝਦਾ ਕਿ ਇਹ ਕਿਉਂ ਕੰਮ ਕਰਦਾ ਹੈ - ਉੱਥੇ ਹੀ ਇੱਕ ਸਟੈਕ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ. ਪਰ "ਅਸੀਂ ਅਭਿਆਸੀ ਹਾਂ: ਸਭ ਕੁਝ ਸਾਡੇ ਲਈ ਕੰਮ ਕਰਦਾ ਹੈ, ਪਰ ਕੋਈ ਨਹੀਂ ਜਾਣਦਾ ਕਿ ਕਿਉਂ..."

// 2gbubble.c
// Usage: LD_PRELOAD=2gbubble.so <program>

#include <sys/mman.h>
#include <assert.h>

void __attribute__((constructor)) constr(void)
{
  assert(MAP_FAILED != mmap(1u >> 31, (1u >> 31) - (1u >> 20), PROT_NONE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0));
}

... ਇਹ ਸੱਚ ਹੈ ਕਿ ਇਹ Valgrind ਨਾਲ ਅਨੁਕੂਲ ਨਹੀਂ ਹੈ, ਪਰ, ਖੁਸ਼ਕਿਸਮਤੀ ਨਾਲ, Valgrind ਖੁਦ ਬਹੁਤ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਹਰ ਕਿਸੇ ਨੂੰ ਉਥੋਂ ਬਾਹਰ ਧੱਕਦਾ ਹੈ :)

ਸ਼ਾਇਦ ਕੋਈ ਇਸ ਗੱਲ ਦੀ ਬਿਹਤਰ ਵਿਆਖਿਆ ਕਰੇਗਾ ਕਿ ਮੇਰਾ ਇਹ ਕੋਡ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ ...

ਸਰੋਤ: www.habr.com