QEMU.js: હવે ગંભીર અને WASM સાથે

એક સમયે મેં આનંદ માટે નિર્ણય કર્યો પ્રક્રિયાની ઉલટાવી શકાય તેવું સાબિત કરો અને મશીન કોડમાંથી JavaScript (વધુ સ્પષ્ટ રીતે, Asm.js) કેવી રીતે જનરેટ કરવું તે શીખો. પ્રયોગ માટે QEMU પસંદ કરવામાં આવ્યું હતું, અને થોડા સમય પછી Habr પર એક લેખ લખવામાં આવ્યો હતો. ટિપ્પણીઓમાં મને વેબ એસેમ્બલીમાં પ્રોજેક્ટને રીમેક કરવાની સલાહ આપવામાં આવી હતી, અને મારી જાતને છોડી પણ દીધી હતી લગભગ સમાપ્ત હું કોઈક રીતે પ્રોજેક્ટ ઇચ્છતો ન હતો... કામ ચાલી રહ્યું હતું, પરંતુ ખૂબ જ ધીરે ધીરે, અને હવે, તે લેખમાં તાજેતરમાં દેખાયો ભાષ્ય વિષય પર "તો તે બધું કેવી રીતે સમાપ્ત થયું?" મારા વિગતવાર જવાબના જવાબમાં, મેં "આ લેખ જેવું લાગે છે" સાંભળ્યું. સારું, જો તમે કરી શકો, તો એક લેખ હશે. કદાચ કોઈને તે ઉપયોગી થશે. તેમાંથી વાચક QEMU કોડ જનરેશન બેકએન્ડની ડિઝાઇન વિશેની કેટલીક હકીકતો તેમજ વેબ એપ્લિકેશન માટે જસ્ટ-ઇન-ટાઇમ કમ્પાઇલર કેવી રીતે લખવું તે શીખશે.

કાર્યો

જાવાસ્ક્રિપ્ટમાં QEMU ને કેવી રીતે "કોઈક રીતે" પોર્ટ કરવું તે મેં પહેલેથી જ શીખી લીધું હોવાથી, આ વખતે તે સમજદારીપૂર્વક કરવાનું અને જૂની ભૂલોનું પુનરાવર્તન ન કરવાનું નક્કી કર્યું.

ભૂલ નંબર એક: બિંદુ પ્રકાશનમાંથી શાખા

મારી પ્રથમ ભૂલ અપસ્ટ્રીમ સંસ્કરણ 2.4.1 થી મારા સંસ્કરણને ફોર્ક કરવાની હતી. પછી તે મને એક સારો વિચાર લાગ્યો: જો બિંદુ પ્રકાશન અસ્તિત્વમાં છે, તો તે કદાચ સરળ 2.4 કરતાં વધુ સ્થિર છે, અને તેથી પણ વધુ શાખા master. અને મેં મારી પોતાની ભૂલોની યોગ્ય માત્રા ઉમેરવાનું આયોજન કર્યું હોવાથી, મને બીજા કોઈની જરૂર નથી. તે કદાચ તે કેવી રીતે બહાર આવ્યું છે. પરંતુ અહીં વાત છે: QEMU સ્થિર રહેતું નથી, અને અમુક સમયે તેઓએ જનરેટ કરેલા કોડને 10 ટકા ઓપ્ટિમાઇઝ કરવાની જાહેરાત પણ કરી હતી. "હા, હવે હું સ્થિર થવા જઈ રહ્યો છું," મેં વિચાર્યું અને તૂટી પડ્યું. અહીં આપણે એક વિષયાંતર કરવાની જરૂર છે: QEMU.js ની સિંગલ-થ્રેડેડ પ્રકૃતિને કારણે અને હકીકત એ છે કે મૂળ QEMU મલ્ટી-થ્રેડીંગની ગેરહાજરી સૂચિત કરતું નથી (એટલે ​​​​કે, એકસાથે અનેક અસંબંધિત કોડ પાથ ચલાવવાની ક્ષમતા, અને ફક્ત "બધા કર્નલોનો ઉપયોગ કરો") તે માટે મહત્વપૂર્ણ નથી, બહારથી કૉલ કરવા માટે સક્ષમ થવા માટે મારે "તેને ચાલુ" કરવું પડ્યું હતું તે થ્રેડોના મુખ્ય કાર્યો. આનાથી વિલીનીકરણ દરમિયાન કેટલીક કુદરતી સમસ્યાઓ ઊભી થઈ. જો કે, શાળામાંથી કેટલાક ફેરફારોની હકીકત છે master, જેની સાથે મેં મારા કોડને મર્જ કરવાનો પ્રયાસ કર્યો હતો, તે પણ પોઈન્ટ રીલીઝમાં (અને તેથી મારી શાખામાં) ચેરી પસંદ કરવામાં આવી હતી તે પણ કદાચ સગવડતા ઉમેરશે નહીં.

સામાન્ય રીતે, મેં નક્કી કર્યું કે પ્રોટોટાઇપને ફેંકી દેવાનો, તેને ભાગો માટે ડિસએસેમ્બલ કરવાનો અને નવા વર્ઝનને કંઈક ફ્રેશના આધારે અને હવેથી બનાવવાનો હજુ પણ અર્થ છે. master.

ભૂલ નંબર બે: TLP પદ્ધતિ

સારમાં, આ કોઈ ભૂલ નથી, સામાન્ય રીતે, તે "ક્યાં અને કેવી રીતે ખસેડવું?" અને સામાન્ય રીતે "શું આપણે ત્યાં પહોંચીશું?" બંનેની સંપૂર્ણ ગેરસમજની સ્થિતિમાં પ્રોજેક્ટ બનાવવાની એક વિશેષતા છે. આ પરિસ્થિતિઓમાં અણઘડ પ્રોગ્રામિંગ એક વાજબી વિકલ્પ હતો, પરંતુ, સ્વાભાવિક રીતે, હું તેને બિનજરૂરી રીતે પુનરાવર્તન કરવા માંગતો ન હતો. આ વખતે હું તેને સમજદારીપૂર્વક કરવા માંગતો હતો: પરમાણુ કમિટ, સભાન કોડ ફેરફારો (અને "જેમ કે તે કમ્પાઇલ ન થાય ત્યાં સુધી રેન્ડમ અક્ષરોને એકસાથે જોડવા નહીં (ચેતવણીઓ સાથે)", જેમ કે લિનસ ટોરવાલ્ડ્સે એકવાર કોઈ વિશે કહ્યું હતું, વિકિક્વોટ મુજબ), વગેરે.

ભૂલ નંબર ત્રણ: ફોર્ડને જાણ્યા વિના પાણીમાં ઉતરવું

હું હજી પણ આમાંથી સંપૂર્ણપણે છુટકારો મેળવ્યો નથી, પરંતુ હવે મેં ઓછામાં ઓછા પ્રતિકારના માર્ગને અનુસરવાનું નહીં, અને "વૃદ્ધ થઈ ગયેલા માર્ગ" તરીકે કરવાનું નક્કી કર્યું છે, એટલે કે, મારા TCG બેકએન્ડને શરૂઆતથી લખો, જેથી ન થાય. પછીથી કહેવું પડશે, "હા, આ અલબત્ત, ધીમે ધીમે છે, પરંતુ હું બધું નિયંત્રિત કરી શકતો નથી - આ રીતે TCI લખાયેલ છે..." તદુપરાંત, આ શરૂઆતમાં સ્પષ્ટ ઉકેલ જેવું લાગતું હતું, કારણ કે હું બાઈનરી કોડ જનરેટ કરું છું. જેમ તેઓ કહે છે, “ઘેન્ટ ભેગા થયાу, પરંતુ તે એક નથી”: કોડ, અલબત્ત, દ્વિસંગી છે, પરંતુ નિયંત્રણ ફક્ત તેને સ્થાનાંતરિત કરી શકાતું નથી - તેને સંકલન માટે બ્રાઉઝરમાં સ્પષ્ટપણે દબાણ કરવું આવશ્યક છે, પરિણામે JS વિશ્વમાંથી ચોક્કસ ઑબ્જેક્ટ આવે છે, જે હજુ પણ જરૂરી છે. ક્યાંક સાચવવામાં આવે છે. જો કે, સામાન્ય RISC આર્કિટેક્ચર્સ પર, જ્યાં સુધી હું સમજું છું, એક લાક્ષણિક પરિસ્થિતિ એ પુનઃજનિત કોડ માટે સૂચના કેશને સ્પષ્ટપણે રીસેટ કરવાની જરૂર છે - જો આ આપણને જોઈતું નથી, તો પછી, કોઈ પણ સંજોગોમાં, તે નજીક છે. વધુમાં, મારા છેલ્લા પ્રયાસથી, મેં શીખ્યું કે નિયંત્રણને અનુવાદ બ્લોકની મધ્યમાં સ્થાનાંતરિત કરવામાં આવ્યું હોય તેવું લાગતું નથી, તેથી અમને ખરેખર કોઈપણ ઑફસેટમાંથી અર્થઘટન કરાયેલ બાઇટકોડની જરૂર નથી, અને અમે તેને ટીબી પરના ફંક્શનમાંથી ફક્ત જનરેટ કરી શકીએ છીએ. .

તેઓ આવ્યા અને લાત મારી

જો કે મેં જુલાઈમાં કોડને ફરીથી લખવાનું શરૂ કર્યું, એક જાદુઈ કિક કોઈનું ધ્યાન ન આવ્યું: સામાન્ય રીતે ગિટહબ તરફથી પત્રો મુદ્દાઓ અને પુલ વિનંતીઓના જવાબો વિશે સૂચનાઓ તરીકે આવે છે, પરંતુ અહીં, અચાનક થ્રેડમાં ઉલ્લેખ કરો qemu બેકએન્ડ તરીકે Binaryen સંદર્ભમાં, "તેણે એવું કંઈક કર્યું, કદાચ તે કંઈક કહેશે." અમે Emscripten સંબંધિત લાઇબ્રેરીનો ઉપયોગ કરવા વિશે વાત કરી રહ્યા હતા બાઈનરીન WASM JIT બનાવવા માટે. સારું, મેં કહ્યું કે તમારી પાસે ત્યાં Apache 2.0 લાયસન્સ છે, અને QEMU એકંદરે GPLv2 હેઠળ વિતરિત થયેલ છે, અને તે ખૂબ સુસંગત નથી. અચાનક તે બહાર આવ્યું કે લાઇસન્સ હોઈ શકે છે તેને કોઈક રીતે ઠીક કરો (મને ખબર નથી: કદાચ તેને બદલો, કદાચ ડ્યુઅલ લાઇસન્સ, કદાચ બીજું કંઈક...). આ, અલબત્ત, મને આનંદ થયો, કારણ કે તે સમય સુધીમાં મેં પહેલેથી જ નજીકથી જોયું હતું બાઈનરી ફોર્મેટ WebAssembly, અને હું કોઈક રીતે ઉદાસી અને અગમ્ય હતો. ત્યાં એક પુસ્તકાલય પણ હતું જે સંક્રમણ ગ્રાફ સાથે મૂળભૂત બ્લોક્સને ખાઈ જશે, બાઈટકોડ બનાવશે અને જો જરૂરી હોય તો તેને દુભાષિયામાં જ ચલાવશે.

પછી ત્યાં વધુ હતી એક પત્ર QEMU મેઇલિંગ સૂચિ પર, પરંતુ આ પ્રશ્ન વિશે વધુ છે, "કોને તેની કોઈપણ રીતે જરૂર છે?" અને તે છે અચાનક, તે જરૂરી હતું તે બહાર આવ્યું. ઓછામાં ઓછા, તમે ઉપયોગની નીચેની શક્યતાઓને એકસાથે ઉઝરડા કરી શકો છો, જો તે વધુ કે ઓછા ઝડપથી કામ કરે છે:

• કોઈપણ ઇન્સ્ટોલેશન વિના કંઈક શૈક્ષણિક લોન્ચ કરવું
• iOS પર વર્ચ્યુઅલાઈઝેશન, જ્યાં, અફવાઓ અનુસાર, ફ્લાય પર કોડ જનરેશન કરવાનો અધિકાર ધરાવતી એકમાત્ર એપ્લિકેશન જેએસ એન્જિન છે (શું આ સાચું છે?)
• મિની-ઓએસનું પ્રદર્શન - સિંગલ-ફ્લોપી, બિલ્ટ-ઇન, તમામ પ્રકારના ફર્મવેર, વગેરે...

બ્રાઉઝર રનટાઇમ સુવિધાઓ

મેં પહેલેથી જ કહ્યું તેમ, QEMU મલ્ટિથ્રેડિંગ સાથે જોડાયેલું છે, પરંતુ બ્રાઉઝર પાસે તે નથી. સારું, એટલે કે, ના... શરૂઆતમાં તે બિલકુલ અસ્તિત્વમાં નહોતું, પછી વેબવર્કર્સ દેખાયા - જ્યાં સુધી હું સમજું છું, આ મલ્ટિથ્રેડીંગ મેસેજ પાસિંગ પર આધારિત છે વહેંચાયેલ ચલો વિના. સ્વાભાવિક રીતે, શેર કરેલ મેમરી મોડલ પર આધારિત હાલના કોડને પોર્ટ કરતી વખતે આ નોંધપાત્ર સમસ્યાઓ બનાવે છે. પછી જાહેર દબાણ હેઠળ તેને નામથી અમલમાં મુકવામાં આવ્યું હતું SharedArrayBuffers. તે ધીમે ધીમે રજૂ કરવામાં આવ્યું, તેઓએ જુદા જુદા બ્રાઉઝર્સમાં તેના લોન્ચની ઉજવણી કરી, પછી તેઓએ નવું વર્ષ ઉજવ્યું, અને પછી મેલ્ટડાઉન... જે પછી તેઓ એવા નિષ્કર્ષ પર આવ્યા કે સમય માપન બરછટ અથવા બરછટ છે, પરંતુ વહેંચાયેલ મેમરીની મદદથી. થ્રેડ કાઉન્ટર પર વધારો કરે છે, તે બધા સમાન છે તે ખૂબ સચોટ રીતે કામ કરશે. તેથી અમે વહેંચાયેલ મેમરી સાથે મલ્ટિથ્રેડીંગને અક્ષમ કર્યું. એવું લાગે છે કે તેઓએ તેને પાછળથી ચાલુ કર્યું, પરંતુ, જેમ કે તે પ્રથમ પ્રયોગથી સ્પષ્ટ થઈ ગયું છે, તેના વિના જીવન છે, અને જો એમ હોય, તો અમે મલ્ટિથ્રેડિંગ પર આધાર રાખ્યા વિના તે કરવાનો પ્રયાસ કરીશું.

બીજી સુવિધા એ સ્ટેક સાથે નિમ્ન-સ્તરની મેનીપ્યુલેશન્સની અશક્યતા છે: તમે ફક્ત વર્તમાન સંદર્ભને લઈ શકતા નથી, વર્તમાન સંદર્ભને સાચવી શકતા નથી અને નવા સ્ટેક સાથે નવા પર સ્વિચ કરી શકતા નથી. કોલ સ્ટેક જેએસ વર્ચ્યુઅલ મશીન દ્વારા સંચાલિત થાય છે. એવું લાગે છે કે, સમસ્યા શું છે, કારણ કે અમે હજી પણ અગાઉના પ્રવાહોને સંપૂર્ણપણે જાતે સંચાલિત કરવાનું નક્કી કર્યું છે? હકીકત એ છે કે QEMU માં બ્લોક I/O નો અમલ કોરોટીન દ્વારા કરવામાં આવે છે, અને આ તે છે જ્યાં નિમ્ન-સ્તરના સ્ટેક મેનિપ્યુલેશન્સ હાથમાં આવશે. સદનસીબે, Emscipten માં પહેલેથી જ અસુમેળ કામગીરી માટે એક પદ્ધતિ છે, બે પણ: Asyncify и એમ્પટરપ્રીટર. પ્રથમ જનરેટ કરેલા JavaScript કોડમાં નોંધપાત્ર બ્લોટ દ્વારા કામ કરે છે અને હવે તે સપોર્ટેડ નથી. બીજો વર્તમાન "સાચો માર્ગ" છે અને મૂળ દુભાષિયા માટે બાઈટકોડ જનરેશન દ્વારા કામ કરે છે. તે, અલબત્ત, ધીમે ધીમે કામ કરે છે, પરંતુ તે કોડને ખીલતું નથી. સાચું, આ મિકેનિઝમ માટે કોરોટીન માટે આધાર સ્વતંત્ર રીતે ફાળો આપવો પડતો હતો (ત્યાં પહેલાથી જ Asyncify માટે કોરોટીન લખેલા હતા અને Emterpreter માટે લગભગ સમાન API નો અમલ હતો, તમારે તેમને કનેક્ટ કરવાની જરૂર છે).

આ ક્ષણે, મેં હજી સુધી WASM માં કમ્પાઇલ કરેલા કોડને વિભાજિત કરવામાં અને એમ્ટરપ્રીટરનો ઉપયોગ કરીને અર્થઘટન કરવામાં વ્યવસ્થાપિત નથી, તેથી બ્લોક ઉપકરણો હજી કામ કરતા નથી (આગળની શ્રેણીમાં જુઓ, જેમ તેઓ કહે છે...). એટલે કે, અંતે તમારે આ રમુજી સ્તરવાળી વસ્તુ જેવું કંઈક મેળવવું જોઈએ:

• અર્થઘટન કરેલ બ્લોક I/O. સારું, શું તમે ખરેખર મૂળ પ્રદર્શન સાથે એમ્યુલેટેડ NVMeની અપેક્ષા રાખી હતી? 🙂
• સ્ટેટિકલી કમ્પાઈલ કરેલ મુખ્ય QEMU કોડ (અનુવાદક, અન્ય એમ્યુલેટેડ ઉપકરણો વગેરે)
• WASM માં ગેસ્ટ કોડને ગતિશીલ રીતે સંકલિત કરે છે

QEMU સ્ત્રોતોની વિશેષતાઓ

જેમ તમે કદાચ પહેલેથી જ અનુમાન લગાવ્યું હશે, ગેસ્ટ આર્કિટેક્ચર્સનું અનુકરણ કરવા માટેનો કોડ અને હોસ્ટ મશીન સૂચનાઓ જનરેટ કરવા માટેનો કોડ QEMU માં અલગ કરવામાં આવ્યો છે. હકીકતમાં, તે થોડું મુશ્કેલ પણ છે:

• ત્યાં ગેસ્ટ આર્કિટેક્ચર છે
• છે પ્રવેગક, એટલે કે, Linux પર હાર્ડવેર વર્ચ્યુઅલાઈઝેશન માટે KVM (એકબીજા સાથે સુસંગત મહેમાન અને યજમાન સિસ્ટમો માટે), ગમે ત્યાં JIT કોડ જનરેશન માટે TCG. QEMU 2.9 થી શરૂ કરીને, Windows પર HAXM હાર્ડવેર વર્ચ્યુઅલાઈઝેશન સ્ટાન્ડર્ડ માટે સપોર્ટ દેખાયો (વિગતો)
• જો TCG નો ઉપયોગ કરવામાં આવે છે અને હાર્ડવેર વર્ચ્યુઅલાઈઝેશન નથી, તો તે દરેક હોસ્ટ આર્કિટેક્ચર માટે તેમજ સાર્વત્રિક દુભાષિયા માટે અલગ કોડ જનરેશન સપોર્ટ ધરાવે છે.
• ... અને આ બધાની આસપાસ - એમ્યુલેટેડ પેરિફેરલ્સ, યુઝર ઇન્ટરફેસ, સ્થળાંતર, રેકોર્ડ-રિપ્લે, વગેરે.

માર્ગ દ્વારા, શું તમે જાણો છો: QEMU માત્ર સમગ્ર કમ્પ્યુટરનું અનુકરણ કરી શકે છે, પરંતુ હોસ્ટ કર્નલમાં અલગ વપરાશકર્તા પ્રક્રિયા માટે પ્રોસેસરનું પણ અનુકરણ કરી શકે છે, જેનો ઉપયોગ થાય છે, ઉદાહરણ તરીકે, બાઈનરી ઇન્સ્ટ્રુમેન્ટેશન માટે AFL ફઝર દ્વારા. કદાચ કોઈ ક્યુઈએમયુના ઓપરેશનના આ મોડને જેએસમાં પોર્ટ કરવા માંગે છે? 😉

મોટાભાગના લાંબા સમયથી ચાલતા ફ્રી સોફ્ટવેરની જેમ, QEMU કોલ દ્વારા બનાવવામાં આવે છે configure и make. ચાલો કહીએ કે તમે કંઈક ઉમેરવાનું નક્કી કર્યું છે: TCG બેકએન્ડ, થ્રેડ અમલીકરણ, બીજું કંઈક. ઑટોકોન્ફ સાથે વાતચીત કરવાની સંભાવના પર ખુશ/ગભરાઈ જવા માટે ઉતાવળ કરશો નહીં (યોગ્ય તરીકે રેખાંકિત કરો) - હકીકતમાં, configure QEMU દેખીતી રીતે સ્વ-લેખિત છે અને તે કંઈપણમાંથી જનરેટ થયેલ નથી.

વેબઅસ્બાન

તો આ વસ્તુને WebAssembly (ઉર્ફ WASM) શું કહેવાય? આ Asm.js માટે રિપ્લેસમેન્ટ છે, જે હવે માન્ય JavaScript કોડ હોવાનો ઢોંગ કરતું નથી. તેનાથી વિપરિત, તે સંપૂર્ણપણે દ્વિસંગી અને ઑપ્ટિમાઇઝ છે, અને તેમાં ફક્ત પૂર્ણાંક લખવાનું પણ ખૂબ સરળ નથી: કોમ્પેક્ટનેસ માટે, તે ફોર્મેટમાં સંગ્રહિત છે. લેબ 128.

તમે Asm.js માટે રિલૂપિંગ અલ્ગોરિધમ વિશે સાંભળ્યું હશે - આ "ઉચ્ચ-સ્તર" ફ્લો કંટ્રોલ સૂચનાઓનું પુનઃસ્થાપન છે (એટલે ​​​​કે, જો-તો-બીજું, લૂપ્સ, વગેરે), જેના માટે JS એન્જિન ડિઝાઇન કરવામાં આવ્યા છે, લો-લેવલ LLVM IR, પ્રોસેસર દ્વારા ચલાવવામાં આવેલ મશીન કોડની નજીક. સ્વાભાવિક રીતે, QEMU ની મધ્યવર્તી રજૂઆત બીજાની નજીક છે. એવું લાગે છે કે તે અહીં છે, બાયટેકોડ, યાતનાનો અંત... અને પછી બ્લોક્સ છે, જો-તો-બીજું અને લૂપ્સ!..

અને આ બીજું કારણ છે કે બાઈનરીન ઉપયોગી છે: તે કુદરતી રીતે WASM માં જે સંગ્રહિત થશે તેની નજીકના ઉચ્ચ-સ્તરના બ્લોક્સને સ્વીકારી શકે છે. પરંતુ તે મૂળભૂત બ્લોક્સ અને તેમની વચ્ચેના સંક્રમણોના ગ્રાફમાંથી કોડ પણ બનાવી શકે છે. ઠીક છે, મેં પહેલેથી જ કહ્યું છે કે તે અનુકૂળ C/C++ API પાછળ WebAssembly સ્ટોરેજ ફોર્મેટ છુપાવે છે.

ટીસીજી (નાના કોડ જનરેટર)

ટીસીજી મૂળ હતી 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-ઓ:

• ટાર્ગેટ આર્કિટેક્ચર પર કેટલા રજિસ્ટર અને કેટલી પહોળાઈ છે (અમારી પાસે જોઈએ તેટલા છે, જેટલા આપણે જોઈએ છે - પ્રશ્ન એ છે કે "સંપૂર્ણ લક્ષ્ય" આર્કિટેક્ચર પર બ્રાઉઝર દ્વારા વધુ કાર્યક્ષમ કોડમાં શું જનરેટ કરવામાં આવશે તે વિશે વધુ છે. ...)
• યજમાન સૂચનાઓનું સંરેખણ: 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 સ્ટાર્ટઅપ વખતે મેમરી ફાળવે છે અને ત્યાં જનરેટ થયેલ કોડ લખે છે. જ્યારે બફર સમાપ્ત થાય છે, ત્યારે કોડ ફેંકી દેવામાં આવે છે અને પછીનો કોડ તેની જગ્યાએ લખવાનું શરૂ કરે છે.

કોડનો અભ્યાસ કર્યા પછી, મને સમજાયું કે જાદુઈ નંબર સાથેની યુક્તિએ મને પ્રથમ પાસ પર બિન-પ્રારંભિક બફર પર કંઈક ખોટું મુક્ત કરીને ઢગલા વિનાશમાં નિષ્ફળ ન થવાની મંજૂરી આપી. પરંતુ પછીથી મારા કાર્યને બાયપાસ કરવા માટે બફરને કોણ ફરીથી લખે છે? Emscripten વિકાસકર્તાઓની સલાહ મુજબ, જ્યારે મને કોઈ સમસ્યા આવી, ત્યારે મેં પરિણામી કોડને મૂળ એપ્લિકેશન પર પાછો પોર્ટ કર્યો, તેના પર Mozilla Record-Replay સેટ કર્યો... સામાન્ય રીતે, અંતે મને એક સરળ વાત સમજાઈ: દરેક બ્લોક માટે, a struct TranslationBlock તેના વર્ણન સાથે. અનુમાન કરો કે ક્યાં... તે સાચું છે, બફરમાં બ્લોકની બરાબર પહેલાં. આને સમજીને, મેં ક્રેચ (ઓછામાં ઓછા કેટલાક) નો ઉપયોગ કરવાનું છોડી દેવાનું નક્કી કર્યું, અને ફક્ત જાદુઈ નંબર ફેંકી દીધો, અને બાકીના શબ્દોને ટ્રાન્સફર કરી દીધા. struct TranslationBlock, એકલ લિંક કરેલી સૂચિ બનાવવી જે અનુવાદ કેશ રીસેટ થાય ત્યારે ઝડપથી પસાર થઈ શકે છે, અને મેમરીને ખાલી કરી શકે છે.

કેટલાક ક્રૉચ રહે છે: ઉદાહરણ તરીકે, કોડ બફરમાં ચિહ્નિત પોઇન્ટર - તેમાંથી કેટલાક સરળ છે BinaryenExpressionRef, એટલે કે, તેઓ એવા અભિવ્યક્તિઓને જુએ છે કે જે જનરેટ કરેલા મૂળભૂત બ્લોકમાં રેખીય રીતે મૂકવાની જરૂર છે, ભાગ એ BBs વચ્ચે સંક્રમણ માટેની શરત છે, ભાગ એ છે કે ક્યાં જવું છે. ઠીક છે, રિલૂપર માટે પહેલેથી જ તૈયાર બ્લોક્સ છે જે શરતો અનુસાર કનેક્ટ કરવાની જરૂર છે. તેમને અલગ પાડવા માટે, ધારણાનો ઉપયોગ કરવામાં આવે છે કે તે બધા ઓછામાં ઓછા ચાર બાઇટ્સ દ્વારા સંરેખિત છે, જેથી તમે લેબલ માટે ઓછામાં ઓછા નોંધપાત્ર બે બિટ્સનો સુરક્ષિત રીતે ઉપયોગ કરી શકો, જો જરૂરી હોય તો તમારે તેને દૂર કરવાનું યાદ રાખવાની જરૂર છે. માર્ગ દ્વારા, TCG લૂપમાંથી બહાર નીકળવાનું કારણ સૂચવવા માટે QEMU માં આવા લેબલ્સ પહેલેથી જ ઉપયોગમાં લેવાય છે.

Binaryen મદદથી

WebAssembly માં મોડ્યુલ્સ ફંક્શન ધરાવે છે, જેમાંના દરેકમાં એક બોડી હોય છે, જે એક અભિવ્યક્તિ છે. અભિવ્યક્તિઓ એ યુનરી અને દ્વિસંગી ક્રિયાઓ છે, અન્ય અભિવ્યક્તિઓ, નિયંત્રણ પ્રવાહ, વગેરેની સૂચિ ધરાવતા બ્લોક્સ. મેં પહેલેથી જ કહ્યું તેમ, નિયંત્રણ પ્રવાહ અહીં ઉચ્ચ-સ્તરની શાખાઓ, લૂપ્સ, ફંક્શન કૉલ્સ, વગેરે તરીકે ચોક્કસ રીતે ગોઠવવામાં આવે છે. ફંક્શન માટે દલીલો સ્ટેક પર પસાર થતી નથી, પરંતુ સ્પષ્ટ રીતે, JS ની જેમ. ત્યાં વૈશ્વિક ચલો પણ છે, પરંતુ મેં તેનો ઉપયોગ કર્યો નથી, તેથી હું તમને તેમના વિશે કહીશ નહીં.

ફંક્શન્સમાં સ્થાનિક ચલ પણ હોય છે, જે શૂન્યમાંથી નંબર આપવામાં આવે છે, પ્રકારનું: int32 / int64 / float / double. આ કિસ્સામાં, પ્રથમ n સ્થાનિક ચલ એ ફંક્શનમાં પસાર કરાયેલી દલીલો છે. મહેરબાની કરીને નોંધ કરો કે નિયંત્રણ પ્રવાહની દ્રષ્ટિએ અહીં બધું સંપૂર્ણપણે નિમ્ન-સ્તરનું નથી, તેમ છતાં, પૂર્ણાંકો હજી પણ "સહી કરેલ/સહી કરેલ" વિશેષતા ધરાવતા નથી: સંખ્યા કેવી રીતે વર્તે છે તે ઑપરેશન કોડ પર આધારિત છે.

સામાન્ય રીતે કહીએ તો, Binaryen પૂરી પાડે છે સરળ 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 મોડ્યુલોના એક હજાર કરતાં વધુ ઉદાહરણો બનાવવા માંગે છે, તેથી તેણે દરેક માટે વર્ચ્યુઅલ સરનામાંની જગ્યાની એક ગીગાબાઈટ ફાળવી છે...

હમણાં માટે એટલું જ. જો કોઈને રસ હોય તો કદાચ બીજો લેખ હશે. એટલે કે, ત્યાં ઓછામાં ઓછા રહે છે માત્ર બ્લોક ઉપકરણો કામ કરે છે. વેબ એસેમ્બલી મોડ્યુલ્સના સંકલનને અસુમેળ બનાવવાનો પણ અર્થ થઈ શકે છે, જેમ કે JS વિશ્વમાં પ્રચલિત છે, કારણ કે ત્યાં હજુ પણ એક દુભાષિયા છે જે મૂળ મોડ્યુલ તૈયાર ન થાય ત્યાં સુધી આ બધું કરી શકે છે.

છેલ્લે એક કોયડો: તમે 32-બીટ આર્કિટેક્ચર પર બાઈનરી કમ્પાઈલ કરી છે, પરંતુ કોડ, મેમરી ઓપરેશન્સ દ્વારા, બાઈનરીનથી, સ્ટેક પર ક્યાંક અથવા 2-બીટ એડ્રેસ સ્પેસના ઉપલા 32 જીબીમાં બીજે ક્યાંક ચઢે છે. સમસ્યા એ છે કે બાઈનરીનના દૃષ્ટિકોણથી આ પરિણામી સરનામું ખૂબ મોટું છે. આની આસપાસ કેવી રીતે મેળવવું?

એડમિન ની રીતે

મેં આનું પરીક્ષણ કરવાનું સમાપ્ત કર્યું નથી, પરંતુ મારો પ્રથમ વિચાર એ હતો કે "જો હું 32-બીટ Linux ઇન્સ્ટોલ કરું તો શું?" પછી એડ્રેસ સ્પેસનો ઉપરનો ભાગ કર્નલ દ્વારા કબજે કરવામાં આવશે. એકમાત્ર પ્રશ્ન એ છે કે કેટલો કબજો લેવામાં આવશે: 1 અથવા 2 Gb.

પ્રોગ્રામરની રીતે (પ્રેક્ટિશનરો માટે વિકલ્પ)

ચાલો સરનામાની જગ્યાની ટોચ પર એક બબલ ઉડાવીએ. હું મારી જાતને સમજી શકતો નથી કે તે શા માટે કામ કરે છે - ત્યાં પહેલેથી એક સ્ટેક હોવો જોઈએ. પરંતુ "અમે પ્રેક્ટિશનર્સ છીએ: બધું આપણા માટે કામ કરે છે, પરંતુ કોઈને ખબર નથી કે શા માટે..."

// 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