QEMU.js: ഇപ്പോൾ ഗുരുതരവും WASM-നൊപ്പം

ഒരിക്കൽ ഞാൻ വിനോദത്തിനായി തീരുമാനിച്ചു പ്രക്രിയയുടെ റിവേഴ്സിബിലിറ്റി തെളിയിക്കുക കൂടാതെ മെഷീൻ കോഡിൽ നിന്ന് JavaScript (കൂടുതൽ കൃത്യമായി, Asm.js) സൃഷ്ടിക്കുന്നത് എങ്ങനെയെന്ന് അറിയുക. പരീക്ഷണത്തിനായി QEMU തിരഞ്ഞെടുത്തു, കുറച്ച് സമയത്തിന് ശേഷം ഹബറിനെക്കുറിച്ച് ഒരു ലേഖനം എഴുതപ്പെട്ടു. അഭിപ്രായങ്ങളിൽ, വെബ് അസംബ്ലിയിൽ പ്രോജക്റ്റ് റീമേക്ക് ചെയ്യാനും സ്വയം ഉപേക്ഷിക്കാനും എന്നെ ഉപദേശിച്ചു. ഏതാണ്ട് പൂർത്തിയായി എനിക്ക് എങ്ങനെയെങ്കിലും പ്രോജക്റ്റ് വേണ്ടായിരുന്നു ... ജോലി നടക്കുന്നു, പക്ഷേ വളരെ സാവധാനത്തിലാണ്, ഇപ്പോൾ, അടുത്തിടെ ആ ലേഖനത്തിൽ പ്രത്യക്ഷപ്പെട്ടു കമന്ററി "അപ്പോൾ എല്ലാം എങ്ങനെ അവസാനിച്ചു?" എന്ന വിഷയത്തിൽ എന്റെ വിശദമായ ഉത്തരത്തിനുള്ള മറുപടിയായി, "ഇതൊരു ലേഖനം പോലെ തോന്നുന്നു" എന്ന് ഞാൻ കേട്ടു. ശരി, നിങ്ങൾക്ക് കഴിയുമെങ്കിൽ, ഒരു ലേഖനം ഉണ്ടാകും. ഒരുപക്ഷേ ആരെങ്കിലും അത് ഉപയോഗപ്രദമാണെന്ന് കണ്ടെത്തും. QEMU കോഡ് ജനറേഷൻ ബാക്കെൻഡുകളുടെ രൂപകൽപ്പനയെക്കുറിച്ചും ഒരു വെബ് ആപ്ലിക്കേഷനായി ഒരു ജസ്റ്റ്-ഇൻ-ടൈം കംപൈലർ എങ്ങനെ എഴുതാമെന്നതിനെക്കുറിച്ചും അതിൽ നിന്ന് വായനക്കാരൻ ചില വസ്തുതകൾ പഠിക്കും.

ചുമതലകൾ

ജാവാസ്ക്രിപ്റ്റിലേക്ക് ക്യുഇഎംയു എങ്ങനെ പോർട്ട് ചെയ്യാമെന്ന് ഞാൻ ഇതിനകം പഠിച്ചിരുന്നതിനാൽ, ഇത്തവണ അത് വിവേകത്തോടെ ചെയ്യാനും പഴയ തെറ്റുകൾ ആവർത്തിക്കാതിരിക്കാനും തീരുമാനിച്ചു.

പിശക് നമ്പർ ഒന്ന്: പോയിന്റ് റിലീസിൽ നിന്നുള്ള ശാഖ

അപ്‌സ്ട്രീം പതിപ്പ് 2.4.1-ൽ നിന്ന് എന്റെ പതിപ്പ് ഫോർക്ക് ചെയ്തതാണ് എന്റെ ആദ്യത്തെ തെറ്റ്. അപ്പോൾ എനിക്ക് ഇത് ഒരു നല്ല ആശയമായി തോന്നി: പോയിന്റ് റിലീസ് നിലവിലുണ്ടെങ്കിൽ, അത് ലളിതമായ 2.4-നേക്കാൾ കൂടുതൽ സ്ഥിരതയുള്ളതാണ്, അതിലുപരിയായി ബ്രാഞ്ച് master. എന്റെ സ്വന്തം ബഗുകളുടെ ന്യായമായ തുക ചേർക്കാൻ ഞാൻ പദ്ധതിയിട്ടിരുന്നതിനാൽ, എനിക്ക് മറ്റാരുടെയും ആവശ്യമില്ല. അങ്ങനെയായിരിക്കാം അത് സംഭവിച്ചത്. എന്നാൽ ഇവിടെ കാര്യം ഇതാണ്: QEMU നിശ്ചലമായി നിൽക്കുന്നില്ല, ചില ഘട്ടങ്ങളിൽ അവർ ജനറേറ്റ് ചെയ്ത കോഡിന്റെ 10 ശതമാനം ഒപ്റ്റിമൈസേഷൻ പ്രഖ്യാപിച്ചു. "അതെ, ഇപ്പോൾ ഞാൻ മരവിപ്പിക്കാൻ പോകുന്നു," ഞാൻ ചിന്തിച്ച് തകർന്നു. ഇവിടെ നമ്മൾ ഒരു വ്യതിചലനം നടത്തേണ്ടതുണ്ട്: QEMU.js-ന്റെ സിംഗിൾ-ത്രെഡഡ് സ്വഭാവവും യഥാർത്ഥ QEMU മൾട്ടി-ത്രെഡിംഗിന്റെ അഭാവത്തെ സൂചിപ്പിക്കുന്നില്ല എന്ന വസ്തുതയും (അതായത്, ബന്ധമില്ലാത്ത നിരവധി കോഡ് പാതകൾ ഒരേസമയം പ്രവർത്തിപ്പിക്കാനുള്ള കഴിവ്, കൂടാതെ "എല്ലാ കേർണലുകളും ഉപയോഗിക്കുക" എന്നല്ല) ഇതിന് നിർണ്ണായകമാണ്, ത്രെഡുകളുടെ പ്രധാന പ്രവർത്തനങ്ങൾ പുറത്ത് നിന്ന് വിളിക്കാൻ എനിക്ക് "അത് മാറ്റണം". ഇത് ലയനസമയത്ത് ചില സ്വാഭാവിക പ്രശ്നങ്ങൾ സൃഷ്ടിച്ചു. എന്നിരുന്നാലും, ബ്രാഞ്ചിൽ നിന്നുള്ള ചില മാറ്റങ്ങൾ വസ്തുതയാണ് master, ഞാൻ എന്റെ കോഡ് ലയിപ്പിക്കാൻ ശ്രമിച്ചതും പോയിന്റ് റിലീസിൽ (അതിനാൽ എന്റെ ബ്രാഞ്ചിൽ) ചെറി തിരഞ്ഞെടുക്കപ്പെട്ടതും ഒരുപക്ഷേ സൗകര്യം കൂട്ടില്ലായിരുന്നു.

പൊതുവേ, പ്രോട്ടോടൈപ്പ് വലിച്ചെറിയുന്നതും ഭാഗങ്ങൾക്കായി ഡിസ്അസംബ്ലിംഗ് ചെയ്യുന്നതും പുതുമയുള്ളതുമായ ഒന്നിനെ അടിസ്ഥാനമാക്കി ആദ്യം മുതൽ ഒരു പുതിയ പതിപ്പ് നിർമ്മിക്കുന്നതിൽ ഇപ്പോഴും അർത്ഥമുണ്ടെന്ന് ഞാൻ തീരുമാനിച്ചു. master.

തെറ്റ് നമ്പർ രണ്ട്: TLP രീതിശാസ്ത്രം

സാരാംശത്തിൽ, ഇത് ഒരു തെറ്റല്ല, പൊതുവേ, "എവിടെ, എങ്ങനെ നീങ്ങണം?", പൊതുവെ "നമ്മൾ അവിടെ എത്തുമോ?" എന്നിവയെക്കുറിച്ചുള്ള പൂർണ്ണമായ തെറ്റിദ്ധാരണയുടെ സാഹചര്യങ്ങളിൽ ഒരു പ്രോജക്റ്റ് സൃഷ്ടിക്കുന്നതിനുള്ള ഒരു സവിശേഷത മാത്രമാണ് ഇത്. ഈ അവസ്ഥകളിൽ വിചിത്രമായ പ്രോഗ്രാമിംഗ് ന്യായമായ ഒരു ഓപ്ഷനായിരുന്നു, പക്ഷേ, സ്വാഭാവികമായും, അത് അനാവശ്യമായി ആവർത്തിക്കാൻ ഞാൻ ആഗ്രഹിച്ചില്ല. ഇത്തവണ ഞാൻ അത് ബുദ്ധിപൂർവ്വം ചെയ്യാൻ ആഗ്രഹിച്ചു: ആറ്റോമിക് കമ്മിറ്റുകൾ, ബോധപൂർവമായ കോഡ് മാറ്റങ്ങൾ (കൂടാതെ "അത് കംപൈൽ ചെയ്യുന്നതുവരെ ക്രമരഹിതമായ പ്രതീകങ്ങൾ ഒരുമിച്ച് ചേർക്കരുത് (മുന്നറിയിപ്പുകളോടെ)", ലിനസ് ടോർവാൾഡ്സ് ഒരിക്കൽ ഒരാളെക്കുറിച്ച് പറഞ്ഞതുപോലെ, വിക്കി ഉദ്ധരണി പ്രകാരം) മുതലായവ.

തെറ്റ് നമ്പർ മൂന്ന്: ഫോർഡ് അറിയാതെ വെള്ളത്തിൽ ഇറങ്ങുക

ഞാൻ ഇപ്പോഴും ഇതിൽ നിന്ന് പൂർണ്ണമായും മുക്തനായിട്ടില്ല, പക്ഷേ ഇപ്പോൾ ഞാൻ ഏറ്റവും കുറഞ്ഞ പ്രതിരോധത്തിന്റെ പാത പിന്തുടരേണ്ടതില്ലെന്നും “മുതിർന്നയാളെന്ന നിലയിൽ” അത് ചെയ്യാൻ തീരുമാനിച്ചു, അതായത്, ആദ്യം മുതൽ എന്റെ TCG ബാക്കെൻഡ് എഴുതുക. പിന്നീട് പറയേണ്ടി വരും, "അതെ, ഇത് തീർച്ചയായും സാവധാനമാണ്, പക്ഷേ എനിക്ക് എല്ലാം നിയന്ത്രിക്കാൻ കഴിയില്ല - അങ്ങനെയാണ് ടിസിഐ എഴുതിയിരിക്കുന്നത്..." മാത്രമല്ല, ഇത് തുടക്കത്തിൽ വ്യക്തമായ ഒരു പരിഹാരമായി തോന്നി ഞാൻ ബൈനറി കോഡ് സൃഷ്ടിക്കുന്നു. അവർ പറയുന്നതുപോലെ, “ഗെന്റ് ഒത്തുകൂടിу, പക്ഷേ അതൊന്നുമല്ല”: കോഡ് തീർച്ചയായും ബൈനറിയാണ്, പക്ഷേ നിയന്ത്രണം അതിലേക്ക് കൈമാറാൻ കഴിയില്ല - ഇത് കംപൈലേഷനായി ബ്രൗസറിലേക്ക് വ്യക്തമായി തള്ളണം, അതിന്റെ ഫലമായി JS ലോകത്ത് നിന്ന് ഒരു പ്രത്യേക ഒബ്‌ജക്റ്റ് ലഭിക്കും, അത് ഇപ്പോഴും ആവശ്യമാണ്. എവിടെയെങ്കിലും രക്ഷിക്കപ്പെടും. എന്നിരുന്നാലും, സാധാരണ RISC ആർക്കിടെക്ചറുകളിൽ, ഞാൻ മനസ്സിലാക്കിയിടത്തോളം, പുനർനിർമ്മിച്ച കോഡിനായി നിർദ്ദേശ കാഷെ വ്യക്തമായി പുനഃസജ്ജമാക്കേണ്ടതിന്റെ ആവശ്യകതയാണ് ഒരു സാധാരണ സാഹചര്യം - ഇത് ഞങ്ങൾക്ക് ആവശ്യമില്ലെങ്കിൽ, ഏത് സാഹചര്യത്തിലും, അത് അടുത്താണ്. കൂടാതെ, എന്റെ അവസാന ശ്രമത്തിൽ നിന്ന്, വിവർത്തന ബ്ലോക്കിന്റെ മധ്യഭാഗത്തേക്ക് നിയന്ത്രണം കൈമാറ്റം ചെയ്യപ്പെടുന്നില്ലെന്ന് ഞാൻ മനസ്സിലാക്കി, അതിനാൽ ഞങ്ങൾക്ക് ഒരു ഓഫ്‌സെറ്റിൽ നിന്നും വ്യാഖ്യാനിക്കുന്ന ബൈറ്റ്കോഡ് ആവശ്യമില്ല, മാത്രമല്ല ടിബിയിലെ ഫംഗ്‌ഷനിൽ നിന്ന് നമുക്ക് ഇത് സൃഷ്ടിക്കാൻ കഴിയും. .

അവർ വന്ന് ചവിട്ടി

ജൂലൈയിൽ ഞാൻ കോഡ് വീണ്ടും എഴുതാൻ തുടങ്ങിയെങ്കിലും, ശ്രദ്ധിക്കപ്പെടാതെ ഒരു മാജിക് കിക്ക് കടന്നുവന്നു: സാധാരണയായി GitHub-ൽ നിന്നുള്ള കത്തുകൾ പ്രശ്‌നങ്ങൾ, അഭ്യർത്ഥനകൾ എന്നിവയ്ക്കുള്ള പ്രതികരണങ്ങളെക്കുറിച്ചുള്ള അറിയിപ്പുകളായി എത്തുന്നു, പക്ഷേ ഇവിടെ, പെട്ടെന്ന് ത്രെഡിൽ പരാമർശിക്കുക ഒരു ക്യുമു ബാക്ക്‌എൻഡായി ബിനാരെൻ സന്ദർഭത്തിൽ, "അവൻ അങ്ങനെ എന്തെങ്കിലും ചെയ്തു, ഒരുപക്ഷേ അവൻ എന്തെങ്കിലും പറഞ്ഞേക്കാം." എംസ്ക്രിപ്റ്റന്റെ അനുബന്ധ ലൈബ്രറി ഉപയോഗിക്കുന്നതിനെക്കുറിച്ചാണ് ഞങ്ങൾ സംസാരിച്ചത് ബിനാരെൻ WASM JIT സൃഷ്ടിക്കാൻ. ശരി, നിങ്ങൾക്ക് അവിടെ അപ്പാച്ചെ 2.0 ലൈസൻസ് ഉണ്ടെന്ന് ഞാൻ പറഞ്ഞു, കൂടാതെ QEMU മൊത്തത്തിൽ GPLv2 ന് കീഴിൽ വിതരണം ചെയ്യുന്നു, അവ വളരെ അനുയോജ്യമല്ല. ഒരു ലൈസൻസ് ആകാം എന്ന് പെട്ടെന്ന് മനസ്സിലായി എങ്ങനെയെങ്കിലും ശരിയാക്കുക (എനിക്കറിയില്ല: ഒരുപക്ഷേ അത് മാറ്റാം, ചിലപ്പോൾ ഇരട്ട ലൈസൻസിംഗ്, മറ്റെന്തെങ്കിലും ...). ഇത് തീർച്ചയായും എന്നെ സന്തോഷിപ്പിച്ചു, കാരണം അപ്പോഴേക്കും ഞാൻ സൂക്ഷ്മമായി നോക്കിയിരുന്നു ബൈനറി ഫോർമാറ്റ് WebAssembly, ഞാൻ എങ്ങനെയോ ദുഃഖിതനും മനസ്സിലാക്കാൻ കഴിയാത്തവനും ആയിരുന്നു. ട്രാൻസിഷൻ ഗ്രാഫ് ഉപയോഗിച്ച് അടിസ്ഥാന ബ്ലോക്കുകൾ വിഴുങ്ങുകയും ബൈറ്റ്കോഡ് നിർമ്മിക്കുകയും ആവശ്യമെങ്കിൽ ഇന്റർപ്രെറ്ററിൽ തന്നെ പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുന്ന ഒരു ലൈബ്രറിയും ഉണ്ടായിരുന്നു.

പിന്നെ കൂടുതൽ ഉണ്ടായിരുന്നു ഒരു കത്ത് QEMU മെയിലിംഗ് ലിസ്റ്റിൽ, എന്നാൽ ഇത് കൂടുതൽ ചോദ്യമാണ്, "ആർക്കെങ്കിലും ഇത് ആവശ്യമാണ്?" അതും പെട്ടെന്ന്, അത് ആവശ്യമാണെന്ന് തെളിഞ്ഞു. കുറഞ്ഞത്, കൂടുതലോ കുറവോ വേഗത്തിൽ പ്രവർത്തിക്കുന്നുണ്ടെങ്കിൽ, നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന ഉപയോഗ സാധ്യതകൾ ഒരുമിച്ച് സ്ക്രാപ്പ് ചെയ്യാൻ കഴിയും:

• ഇൻസ്റ്റാളേഷൻ ഇല്ലാതെ വിദ്യാഭ്യാസപരമായ എന്തെങ്കിലും സമാരംഭിക്കുന്നു
• iOS-ലെ വെർച്വലൈസേഷൻ, എവിടെ, കിംവദന്തികൾ അനുസരിച്ച്, ഈച്ചയിൽ കോഡ് സൃഷ്ടിക്കാൻ അവകാശമുള്ള ഒരേയൊരു ആപ്ലിക്കേഷൻ ഒരു JS എഞ്ചിൻ ആണ് (ഇത് ശരിയാണോ?)
• മിനി-ഒഎസിന്റെ പ്രദർശനം - സിംഗിൾ-ഫ്ലോപ്പി, ബിൽറ്റ്-ഇൻ, എല്ലാത്തരം ഫേംവെയറുകളും മുതലായവ...

ബ്രൗസർ റൺടൈം ഫീച്ചറുകൾ

ഞാൻ ഇതിനകം പറഞ്ഞതുപോലെ, QEMU മൾട്ടി ത്രെഡിംഗുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു, പക്ഷേ ബ്രൗസറിൽ അത് ഇല്ല. ശരി, അതായത്, ഇല്ല... ആദ്യം അത് നിലവിലില്ല, പിന്നീട് വെബ് വർക്കർമാർ പ്രത്യക്ഷപ്പെട്ടു - ഞാൻ മനസ്സിലാക്കിയിടത്തോളം, ഇത് സന്ദേശം കൈമാറുന്നതിനെ അടിസ്ഥാനമാക്കിയുള്ള മൾട്ടിത്രെഡിംഗ് ആണ് പങ്കിട്ട വേരിയബിളുകൾ ഇല്ലാതെ. സ്വാഭാവികമായും, പങ്കിട്ട മെമ്മറി മോഡലിനെ അടിസ്ഥാനമാക്കി നിലവിലുള്ള കോഡ് പോർട്ട് ചെയ്യുമ്പോൾ ഇത് കാര്യമായ പ്രശ്നങ്ങൾ സൃഷ്ടിക്കുന്നു. പിന്നെ, ജനകീയ സമ്മർദത്തിനു വഴങ്ങി അതും പേരിൽ നടപ്പാക്കി SharedArrayBuffers. ഇത് ക്രമേണ അവതരിപ്പിച്ചു, അവർ വ്യത്യസ്ത ബ്രൗസറുകളിൽ അതിന്റെ ലോഞ്ച് ആഘോഷിച്ചു, പിന്നെ അവർ പുതുവത്സരം ആഘോഷിച്ചു, പിന്നെ മെൽറ്റ്ഡൗൺ... അതിനുശേഷം അവർ സമയത്തിന്റെ അളവുകോൽ പരുക്കൻ അല്ലെങ്കിൽ പരുക്കൻ എന്ന നിഗമനത്തിലെത്തി, എന്നാൽ പങ്കിട്ട മെമ്മറിയുടെ സഹായത്തോടെ ത്രെഡ് കൗണ്ടർ വർദ്ധിപ്പിക്കുന്നു, എല്ലാം ഒന്നുതന്നെയാണ് അത് വളരെ കൃത്യമായി പ്രവർത്തിക്കും. അതിനാൽ ഞങ്ങൾ പങ്കിട്ട മെമ്മറി ഉപയോഗിച്ച് മൾട്ടിത്രെഡിംഗ് പ്രവർത്തനരഹിതമാക്കി. അവർ പിന്നീട് അത് വീണ്ടും ഓണാക്കിയതായി തോന്നുന്നു, പക്ഷേ, ആദ്യ പരീക്ഷണത്തിൽ നിന്ന് വ്യക്തമായതിനാൽ, അതില്ലാതെ ഒരു ജീവിതമുണ്ട്, അങ്ങനെയാണെങ്കിൽ, മൾട്ടിത്രെഡിംഗിനെ ആശ്രയിക്കാതെ ഞങ്ങൾ അത് ചെയ്യാൻ ശ്രമിക്കും.

രണ്ടാമത്തെ സവിശേഷത, സ്റ്റാക്ക് ഉപയോഗിച്ച് താഴ്ന്ന നിലയിലുള്ള കൃത്രിമത്വം അസാധ്യമാണ്: നിങ്ങൾക്ക് ലളിതമായി എടുക്കാനും നിലവിലെ സന്ദർഭം സംരക്ഷിക്കാനും പുതിയ സ്റ്റാക്ക് ഉപയോഗിച്ച് പുതിയതിലേക്ക് മാറാനും കഴിയില്ല. കോൾ സ്റ്റാക്ക് കൈകാര്യം ചെയ്യുന്നത് JS വെർച്വൽ മെഷീനാണ്. മുമ്പത്തെ ഒഴുക്ക് പൂർണ്ണമായും സ്വമേധയാ കൈകാര്യം ചെയ്യാൻ ഞങ്ങൾ ഇപ്പോഴും തീരുമാനിച്ചതിനാൽ എന്താണ് പ്രശ്‌നം എന്ന് തോന്നുന്നു? ക്യുഇഎംയുവിലെ ബ്ലോക്ക് I/O കോറൂട്ടിനുകളിലൂടെയാണ് നടപ്പിലാക്കുന്നത് എന്നതാണ് വസ്തുത, ഇവിടെയാണ് ലോ-ലെവൽ സ്റ്റാക്ക് കൃത്രിമങ്ങൾ ഉപയോഗപ്രദമാകുന്നത്. ഭാഗ്യവശാൽ, Emscipten-ൽ ഇതിനകം തന്നെ അസിൻക്രണസ് പ്രവർത്തനങ്ങൾക്കുള്ള ഒരു സംവിധാനം അടങ്ങിയിരിക്കുന്നു, രണ്ടെണ്ണം പോലും: സമന്വയിപ്പിക്കുക и വ്യാഖ്യാതാവ്. ആദ്യത്തേത് ജനറേറ്റ് ചെയ്‌ത JavaScript കോഡിലെ കാര്യമായ ബ്ലോട്ടിലൂടെ പ്രവർത്തിക്കുന്നു, അത് ഇനി പിന്തുണയ്‌ക്കില്ല. രണ്ടാമത്തേത് നിലവിലെ "ശരിയായ വഴി" ആണ്, കൂടാതെ നേറ്റീവ് ഇന്റർപ്രെറ്ററിനായി ബൈറ്റ്കോഡ് ജനറേഷൻ വഴി പ്രവർത്തിക്കുന്നു. ഇത് തീർച്ചയായും സാവധാനത്തിൽ പ്രവർത്തിക്കുന്നു, പക്ഷേ ഇത് കോഡ് വീർപ്പിക്കുന്നില്ല. ശരിയാണ്, ഈ മെക്കാനിസത്തിനായുള്ള coroutines-നുള്ള പിന്തുണ സ്വതന്ത്രമായി സംഭാവന ചെയ്യേണ്ടതുണ്ട് (Asyncify-യ്‌ക്കായി ഇതിനകം തന്നെ coroutines എഴുതിയിരുന്നു, കൂടാതെ Emterpreter-ന് ഏകദേശം ഒരേ API നടപ്പിലാക്കുകയും ചെയ്തു, നിങ്ങൾ അവയെ ബന്ധിപ്പിക്കേണ്ടതുണ്ട്).

ഇപ്പോൾ, WASM-ൽ സമാഹരിച്ചതും Emterpreter ഉപയോഗിച്ച് വ്യാഖ്യാനിച്ചതുമായ കോഡ് വിഭജിക്കാൻ എനിക്ക് ഇതുവരെ കഴിഞ്ഞിട്ടില്ല, അതിനാൽ ബ്ലോക്ക് ഉപകരണങ്ങൾ ഇതുവരെ പ്രവർത്തിക്കുന്നില്ല (അവർ പറയുന്നത് പോലെ അടുത്ത ശ്രേണിയിൽ കാണുക...). അതായത്, അവസാനം നിങ്ങൾക്ക് ഇതുപോലുള്ള രസകരമായ ലേയേർഡ് കാര്യം ലഭിക്കണം:

• വ്യാഖ്യാനിച്ച ബ്ലോക്ക് I/O. ശരി, നേറ്റീവ് പ്രകടനത്തോടെയുള്ള എൻവിഎംയെ നിങ്ങൾ ശരിക്കും പ്രതീക്ഷിച്ചിരുന്നോ? 🙂
• സ്ഥിരമായി സമാഹരിച്ച പ്രധാന QEMU കോഡ് (വിവർത്തകൻ, മറ്റ് എമുലേറ്റഡ് ഉപകരണങ്ങൾ മുതലായവ)
• WASM-ലേക്ക് ചലനാത്മകമായി സമാഹരിച്ച അതിഥി കോഡ്

QEMU ഉറവിടങ്ങളുടെ സവിശേഷതകൾ

നിങ്ങൾ ഇതിനകം ഊഹിച്ചതുപോലെ, ഗസ്റ്റ് ആർക്കിടെക്ചറുകൾ അനുകരിക്കുന്നതിനുള്ള കോഡും ഹോസ്റ്റ് മെഷീൻ നിർദ്ദേശങ്ങൾ സൃഷ്ടിക്കുന്നതിനുള്ള കോഡും QEMU-ൽ വേർതിരിച്ചിരിക്കുന്നു. വാസ്തവത്തിൽ, ഇത് ഒരു ചെറിയ തന്ത്രപരമാണ്:

• അതിഥി വാസ്തുവിദ്യകൾ ഉണ്ട്
• ആകുന്നു ആക്സിലറേറ്ററുകൾ, അതായത്, Linux-ലെ ഹാർഡ്‌വെയർ വിർച്ച്വലൈസേഷനായുള്ള KVM (പരസ്‌പരം പൊരുത്തപ്പെടുന്ന അതിഥി, ഹോസ്റ്റ് സിസ്റ്റങ്ങൾക്ക്), എവിടെയും JIT കോഡ് സൃഷ്ടിക്കുന്നതിനുള്ള TCG. QEMU 2.9 മുതൽ, വിൻഡോസിൽ HAXM ഹാർഡ്‌വെയർ വിർച്ച്വലൈസേഷൻ സ്റ്റാൻഡേർഡിനുളള പിന്തുണ പ്രത്യക്ഷപ്പെട്ടു (വിശദാംശങ്ങൾ)
• ഹാർഡ്‌വെയർ വിർച്ച്വലൈസേഷൻ അല്ല TCG ഉപയോഗിക്കുന്നതെങ്കിൽ, അതിന് ഓരോ ഹോസ്റ്റ് ആർക്കിടെക്ചറിനും സാർവത്രിക ഇന്റർപ്രെട്ടറിനും പ്രത്യേക കോഡ് ജനറേഷൻ പിന്തുണയുണ്ട്.
• ... കൂടാതെ ഇതിനെല്ലാം ചുറ്റും - അനുകരിക്കപ്പെട്ട പെരിഫറലുകൾ, ഉപയോക്തൃ ഇന്റർഫേസ്, മൈഗ്രേഷൻ, റെക്കോർഡ്-റീപ്ലേ മുതലായവ.

വഴിയിൽ, നിങ്ങൾക്കറിയാമോ: QEMU വിന് മുഴുവൻ കമ്പ്യൂട്ടറിനെയും മാത്രമല്ല, ഹോസ്റ്റ് കേർണലിലെ ഒരു പ്രത്യേക ഉപയോക്തൃ പ്രക്രിയയ്‌ക്കായുള്ള പ്രോസസറും അനുകരിക്കാൻ കഴിയും, ഉദാഹരണത്തിന്, ബൈനറി ഇൻസ്ട്രുമെന്റേഷനായി AFL ഫസർ ഉപയോഗിക്കുന്നു. QEMU-ന്റെ ഈ പ്രവർത്തന രീതി JS-ലേക്ക് പോർട്ട് ചെയ്യാൻ ആരെങ്കിലും ആഗ്രഹിക്കുന്നുണ്ടോ? 😉

ദീർഘകാല സ്വതന്ത്ര സോഫ്‌റ്റ്‌വെയറുകൾ പോലെ, കോൾ വഴിയാണ് QEMU നിർമ്മിച്ചിരിക്കുന്നത് configure и make. നിങ്ങൾ എന്തെങ്കിലും ചേർക്കാൻ തീരുമാനിച്ചുവെന്നിരിക്കട്ടെ: ഒരു TCG ബാക്കെൻഡ്, ത്രെഡ് നടപ്പിലാക്കൽ, മറ്റെന്തെങ്കിലും. Autoconf-മായി ആശയവിനിമയം നടത്താനുള്ള സാധ്യതയിൽ സന്തോഷിക്കാൻ/ഭയപ്പെടാൻ തിരക്കുകൂട്ടരുത് (ഉചിതമായ രീതിയിൽ അടിവരയിടുക) - വാസ്തവത്തിൽ, configure QEMU-കൾ പ്രത്യക്ഷത്തിൽ സ്വയം എഴുതിയതാണ്, അവ ഒന്നിൽ നിന്നും സൃഷ്ടിക്കപ്പെട്ടതല്ല.

വെബ് അസംബ്ലി

അപ്പോൾ എന്താണ് വെബ് അസംബ്ലി (WASM) എന്ന് വിളിക്കുന്നത്? ഇത് Asm.js-ന് പകരമാണ്, സാധുവായ JavaScript കോഡായി ഇനി നടിക്കുന്നില്ല. നേരെമറിച്ച്, ഇത് പൂർണ്ണമായും ബൈനറിയും ഒപ്റ്റിമൈസ് ചെയ്തതുമാണ്, കൂടാതെ അതിൽ ഒരു പൂർണ്ണസംഖ്യ എഴുതുന്നത് പോലും വളരെ ലളിതമല്ല: ഒതുക്കത്തിനായി, ഇത് ഫോർമാറ്റിൽ സംഭരിച്ചിരിക്കുന്നു. LEB128.

Asm.js-നുള്ള റീലൂപ്പിംഗ് അൽഗോരിതത്തെക്കുറിച്ച് നിങ്ങൾ കേട്ടിരിക്കാം - ഇത് "ഉയർന്ന ലെവൽ" ഫ്ലോ കൺട്രോൾ നിർദ്ദേശങ്ങളുടെ (അതായത്, എങ്കിൽ-ഇല്ലെങ്കിൽ, ലൂപ്പുകൾ മുതലായവ) പുനഃസ്ഥാപിക്കലാണ്, ഇതിനായി JS എഞ്ചിനുകൾ രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു. ലോ-ലെവൽ LLVM IR, പ്രോസസ്സർ എക്സിക്യൂട്ട് ചെയ്യുന്ന മെഷീൻ കോഡിന് അടുത്ത്. സ്വാഭാവികമായും, QEMU ന്റെ ഇന്റർമീഡിയറ്റ് പ്രാതിനിധ്യം രണ്ടാമത്തേതിന് അടുത്താണ്. ബൈറ്റ്കോഡ്, പീഢനത്തിൻ്റെ അന്ത്യം ഇവിടെയാണെന്ന് തോന്നിപ്പോകും... പിന്നെ ബ്ലോക്കുകളും, എങ്കിൽ-ഇല്ലെങ്കിൽ, ലൂപ്പുകളും!..

ബിനാരിൻ ഉപയോഗപ്രദമാകുന്നതിന്റെ മറ്റൊരു കാരണം ഇതാണ്: WASM-ൽ സംഭരിക്കുന്നതിനോട് ചേർന്നുള്ള ഉയർന്ന തലത്തിലുള്ള ബ്ലോക്കുകൾ ഇതിന് സ്വാഭാവികമായും സ്വീകരിക്കാൻ കഴിയും. എന്നാൽ അടിസ്ഥാന ബ്ലോക്കുകളുടെയും അവയ്ക്കിടയിലുള്ള സംക്രമണങ്ങളുടെയും ഗ്രാഫിൽ നിന്ന് കോഡ് നിർമ്മിക്കാനും ഇതിന് കഴിയും. ശരി, ഇത് സൗകര്യപ്രദമായ C/C++ API ന് പിന്നിൽ WebAssembly സ്റ്റോറേജ് ഫോർമാറ്റ് മറയ്ക്കുന്നുവെന്ന് ഞാൻ ഇതിനകം പറഞ്ഞിട്ടുണ്ട്.

ടിസിജി (ചെറിയ കോഡ് ജനറേറ്റർ)

ടിസിജി യഥാർത്ഥത്തിൽ ആയിരുന്നു സി കംപൈലറിനായുള്ള ബാക്കെൻഡ് പിന്നീട്, പ്രത്യക്ഷത്തിൽ, ജിസിസിയുമായുള്ള മത്സരത്തെ നേരിടാൻ ഇതിന് കഴിഞ്ഞില്ല, പക്ഷേ അവസാനം അത് ഹോസ്റ്റ് പ്ലാറ്റ്‌ഫോമിനുള്ള ഒരു കോഡ് ജനറേഷൻ മെക്കാനിസമായി QEMU- ൽ അതിന്റെ സ്ഥാനം കണ്ടെത്തി. ചില അമൂർത്തമായ ബൈറ്റ്കോഡ് സൃഷ്ടിക്കുന്ന ഒരു TCG ബാക്കെൻഡും ഉണ്ട്, അത് വ്യാഖ്യാതാവ് ഉടനടി നടപ്പിലാക്കുന്നു, എന്നാൽ ഇത്തവണ അത് ഉപയോഗിക്കുന്നത് ഒഴിവാക്കാൻ ഞാൻ തീരുമാനിച്ചു. എന്നിരുന്നാലും, ക്യുഇഎംയുവിൽ ഫംഗ്‌ഷനിലൂടെ ജനറേറ്റ് ചെയ്‌ത ടിബിയിലേക്കുള്ള പരിവർത്തനം പ്രവർത്തനക്ഷമമാക്കുന്നത് ഇതിനകം തന്നെ സാധ്യമാണ്. 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 കാഷെയുടെ ഏകദേശ വലുപ്പം എന്താണ്. ക്യുഇഎംയുവിൽ എല്ലാം ഗൗരവമുള്ളതാണ് എന്നതാണ് വസ്‌തുത: അതിഥി എംഎംയു കണക്കിലെടുത്ത് ലോഡ്/സ്റ്റോർ നിർവ്വഹിക്കുന്ന സഹായ പ്രവർത്തനങ്ങൾ ഉണ്ടെങ്കിലും (അത് ഇല്ലാതെ ഞങ്ങൾ ഇപ്പോൾ എവിടെയായിരിക്കും?), അവ അവയുടെ വിവർത്തന കാഷെ ഒരു ഘടനയുടെ രൂപത്തിൽ സംരക്ഷിക്കുന്നു, ബ്രോഡ്കാസ്റ്റ് ബ്ലോക്കുകളിലേക്ക് നേരിട്ട് ഉൾച്ചേർക്കുന്നതിന് സൗകര്യപ്രദമായ പ്രോസസ്സിംഗ്. ചെറുതും വേഗതയേറിയതുമായ കമാൻഡുകൾ ഉപയോഗിച്ച് ഈ ഘടനയിലെ ഏത് ഓഫ്സെറ്റാണ് ഏറ്റവും കാര്യക്ഷമമായി പ്രോസസ്സ് ചെയ്യുന്നത് എന്നതാണ് ചോദ്യം.
• ഇവിടെ നിങ്ങൾക്ക് ഒന്നോ രണ്ടോ റിസർവ് ചെയ്ത രജിസ്റ്ററുകളുടെ ഉദ്ദേശം മാറ്റാം, ഒരു ഫംഗ്ഷനിലൂടെ ടിബി കോളിംഗ് പ്രവർത്തനക്ഷമമാക്കുകയും ഓപ്ഷണലായി രണ്ട് ചെറിയവ വിവരിക്കുകയും ചെയ്യാം inline- പോലുള്ള പ്രവർത്തനങ്ങൾ flush_icache_range (പക്ഷേ ഇത് ഞങ്ങളുടെ കാര്യമല്ല)

ഫയല് tcg-target.inc.c, തീർച്ചയായും, സാധാരണയായി വലുപ്പത്തിൽ വളരെ വലുതാണ് കൂടാതെ നിരവധി നിർബന്ധിത പ്രവർത്തനങ്ങൾ അടങ്ങിയിരിക്കുന്നു:

• ഏതൊക്കെ ഓപ്പറണ്ടുകളിൽ പ്രവർത്തിക്കാനാകുമെന്ന നിയന്ത്രണങ്ങൾ ഉൾപ്പെടെയുള്ള സമാരംഭം. മറ്റൊരു ബാക്കെൻഡിൽ നിന്ന് ഞാൻ നഗ്നമായി പകർത്തിയത്
• ഒരു ആന്തരിക ബൈറ്റ്കോഡ് നിർദ്ദേശം എടുക്കുന്ന ഫംഗ്ഷൻ
• നിങ്ങൾക്ക് ഇവിടെ ഓക്സിലറി ഫംഗ്ഷനുകൾ നൽകാം, കൂടാതെ നിങ്ങൾക്ക് സ്റ്റാറ്റിക് ഫംഗ്ഷനുകളും ഉപയോഗിക്കാം tcg/tcg.c

എനിക്കായി, ഞാൻ ഇനിപ്പറയുന്ന തന്ത്രം തിരഞ്ഞെടുത്തു: അടുത്ത വിവർത്തന ബ്ലോക്കിന്റെ ആദ്യ വാക്കുകളിൽ, ഞാൻ നാല് പോയിന്ററുകൾ എഴുതി: ഒരു ആരംഭ അടയാളം (സമീപത്തുള്ള ഒരു നിശ്ചിത മൂല്യം 0xFFFFFFFF, ഇത് ടിബിയുടെ നിലവിലെ അവസ്ഥ നിർണ്ണയിച്ചു), സന്ദർഭം, ജനറേറ്റഡ് മൊഡ്യൂൾ, ഡീബഗ്ഗിംഗിനുള്ള മാജിക് നമ്പർ. ആദ്യം അടയാളം ഇട്ടു 0xFFFFFFFF - nഎവിടെ n - ഒരു ചെറിയ പോസിറ്റീവ് സംഖ്യ, ഓരോ തവണയും അത് ഇന്റർപ്രെറ്ററിലൂടെ എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ അത് 1 ആയി വർദ്ധിച്ചു. 0xFFFFFFFE, സമാഹാരം നടന്നു, മൊഡ്യൂൾ ഫംഗ്‌ഷൻ ടേബിളിൽ സംരക്ഷിച്ചു, ഒരു ചെറിയ “ലോഞ്ചറിലേക്ക്” ഇറക്കുമതി ചെയ്തു, അതിൽ നിന്ന് എക്‌സിക്യൂഷൻ പോയി tcg_qemu_tb_exec, കൂടാതെ QEMU മെമ്മറിയിൽ നിന്ന് മൊഡ്യൂൾ നീക്കം ചെയ്തു.

ക്ലാസിക്കുകൾ പരാവർത്തനം ചെയ്യാൻ, "ക്രച്ച്, പ്രോജറിന്റെ ഹൃദയത്തിനായി ഈ ശബ്ദത്തിൽ എത്രമാത്രം ഇഴചേർന്നിരിക്കുന്നു ...". എന്നിരുന്നാലും, ഓർമ്മ എവിടെയോ ചോർന്നുപോയി. മാത്രമല്ല, ഇത് ക്യുഇഎംയു നിയന്ത്രിക്കുന്ന മെമ്മറി ആയിരുന്നു! എനിക്ക് ഒരു കോഡ് ഉണ്ടായിരുന്നു, അടുത്ത നിർദ്ദേശം എഴുതുമ്പോൾ (നന്നായി, അതായത്, ഒരു പോയിന്റർ), മുമ്പ് ഈ സ്ഥലത്തുണ്ടായിരുന്ന ലിങ്ക് ഇല്ലാതാക്കി, പക്ഷേ ഇത് സഹായിച്ചില്ല. യഥാർത്ഥത്തിൽ, ലളിതമായ സാഹചര്യത്തിൽ, QEMU സ്റ്റാർട്ടപ്പിൽ മെമ്മറി അനുവദിക്കുകയും അവിടെ ജനറേറ്റ് ചെയ്ത കോഡ് എഴുതുകയും ചെയ്യുന്നു. ബഫർ തീർന്നാൽ, കോഡ് പുറത്തേക്ക് വലിച്ചെറിയപ്പെടുകയും അടുത്തത് അതിന്റെ സ്ഥാനത്ത് എഴുതാൻ തുടങ്ങുകയും ചെയ്യുന്നു.

കോഡ് പഠിച്ചതിന് ശേഷം, മാജിക് നമ്പർ ഉപയോഗിച്ചുള്ള തന്ത്രം, ആദ്യ പാസിൽ എന്തെങ്കിലും തെറ്റ് വരുത്തി, ഹീപ്പ് ഡിസോർഡേഷനിൽ പരാജയപ്പെടാതിരിക്കാൻ എന്നെ അനുവദിച്ചുവെന്ന് ഞാൻ മനസ്സിലാക്കി. എന്നാൽ പിന്നീട് എന്റെ ഫംഗ്‌ഷൻ മറികടക്കാൻ ആരാണ് ബഫർ മാറ്റിയെഴുതുന്നത്? എംസ്ക്രിപ്റ്റൻ ഡെവലപ്പർമാർ ഉപദേശിക്കുന്നതുപോലെ, ഞാൻ ഒരു പ്രശ്‌നത്തിൽ അകപ്പെട്ടപ്പോൾ, തത്ഫലമായുണ്ടാകുന്ന കോഡ് നേറ്റീവ് ആപ്ലിക്കേഷനിലേക്ക് തിരികെ പോർട്ട് ചെയ്തു, അതിൽ മോസില്ല റെക്കോർഡ്-റീപ്ലേ സജ്ജമാക്കി... പൊതുവേ, അവസാനം ഞാൻ ഒരു ലളിതമായ കാര്യം മനസ്സിലാക്കി: ഓരോ ബ്ലോക്കിനും, എ struct TranslationBlock അതിന്റെ വിവരണത്തോടെ. എവിടെയാണെന്ന് ഊഹിക്കുക... അത് ശരിയാണ്, ബഫറിലെ ബ്ലോക്കിന് തൊട്ടുമുമ്പ്. ഇത് മനസ്സിലാക്കിയ ഞാൻ ക്രച്ചസ് ഉപയോഗിക്കുന്നത് നിർത്താൻ തീരുമാനിച്ചു (ചിലത് എങ്കിലും), കൂടാതെ മാജിക് നമ്പർ പുറത്തെറിഞ്ഞു, ശേഷിക്കുന്ന വാക്കുകൾ ഇതിലേക്ക് മാറ്റി struct TranslationBlock, വിവർത്തന കാഷെ പുനഃസജ്ജമാക്കുമ്പോൾ വേഗത്തിൽ കടന്നുപോകാൻ കഴിയുന്ന ഒറ്റ ലിങ്ക്ഡ് ലിസ്റ്റ് സൃഷ്ടിക്കുന്നു, കൂടാതെ മെമ്മറി സ്വതന്ത്രമാക്കുകയും ചെയ്യുന്നു.

ചില ഊന്നുവടികൾ അവശേഷിക്കുന്നു: ഉദാഹരണത്തിന്, കോഡ് ബഫറിൽ അടയാളപ്പെടുത്തിയ പോയിന്ററുകൾ - അവയിൽ ചിലത് ലളിതമാണ് BinaryenExpressionRef, അതായത്, ജനറേറ്റ് ചെയ്ത അടിസ്ഥാന ബ്ലോക്കിലേക്ക് രേഖീയമായി ഉൾപ്പെടുത്തേണ്ട എക്സ്പ്രഷനുകൾ അവർ നോക്കുന്നു, ഭാഗം ബിബികൾക്കിടയിലുള്ള പരിവർത്തനത്തിനുള്ള വ്യവസ്ഥയാണ്, ഭാഗം എവിടേക്കാണ് പോകേണ്ടത്. ശരി, റിലൂപ്പറിനായി ഇതിനകം തയ്യാറാക്കിയ ബ്ലോക്കുകൾ ഉണ്ട്, അത് വ്യവസ്ഥകൾക്കനുസരിച്ച് ബന്ധിപ്പിക്കേണ്ടതുണ്ട്. അവയെ വേർതിരിച്ചറിയാൻ, അവയെല്ലാം കുറഞ്ഞത് നാല് ബൈറ്റുകളാൽ വിന്യസിച്ചിട്ടുണ്ടെന്ന് അനുമാനം ഉപയോഗിക്കുന്നു, അതിനാൽ നിങ്ങൾക്ക് സുരക്ഷിതമായി ലേബലിനായി ഏറ്റവും കുറഞ്ഞ രണ്ട് ബിറ്റുകൾ ഉപയോഗിക്കാം, ആവശ്യമെങ്കിൽ അത് നീക്കംചെയ്യാൻ നിങ്ങൾ ഓർമ്മിക്കേണ്ടതുണ്ട്. വഴിയിൽ, TCG ലൂപ്പിൽ നിന്ന് പുറത്തുകടക്കുന്നതിനുള്ള കാരണം സൂചിപ്പിക്കാൻ അത്തരം ലേബലുകൾ QEMU-ൽ ഇതിനകം ഉപയോഗിച്ചിട്ടുണ്ട്.

ബിനാരെൻ ഉപയോഗിക്കുന്നു

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.

വഴിയിൽ, ഡെമോ (നിലവിൽ ഒരു മങ്ങിയ ലൈസൻസ് ഉള്ളത്) ഫയർഫോക്സിൽ മാത്രം നന്നായി പ്രവർത്തിക്കുന്നു. Chrome ഡെവലപ്പർമാർ ആയിരുന്നു എങ്ങനെയോ തയ്യാറായില്ല WebAssembly മൊഡ്യൂളുകളുടെ ആയിരത്തിലധികം സംഭവങ്ങൾ സൃഷ്ടിക്കാൻ ആരെങ്കിലും ആഗ്രഹിക്കുന്നു എന്ന വസ്തുതയിലേക്ക്, അവർ ഓരോന്നിനും ഒരു ജിഗാബൈറ്റ് വെർച്വൽ അഡ്രസ് സ്പേസ് അനുവദിച്ചു...

ഇപ്പോഴത്തേക്ക് ഇത്രമാത്രം. ഒരുപക്ഷേ ആർക്കെങ്കിലും താൽപ്പര്യമുണ്ടെങ്കിൽ മറ്റൊരു ലേഖനം ഉണ്ടാകും. അതായത്, കുറഞ്ഞത് അവശേഷിക്കുന്നു വെറുതെ ബ്ലോക്ക് ഉപകരണങ്ങൾ പ്രവർത്തിപ്പിക്കുക. വെബ് അസംബ്ലി മൊഡ്യൂളുകളുടെ സമാഹാരം ജെഎസ് ലോകത്ത് പതിവ് പോലെ അസമന്വിതമാക്കുന്നത് അർത്ഥമാക്കാം, കാരണം നേറ്റീവ് മൊഡ്യൂൾ തയ്യാറാകുന്നതുവരെ ഇതെല്ലാം ചെയ്യാൻ കഴിയുന്ന ഒരു വ്യാഖ്യാതാവ് ഇപ്പോഴും ഉണ്ട്.

ഒടുവിൽ ഒരു കടങ്കഥ: നിങ്ങൾ ഒരു 32-ബിറ്റ് ആർക്കിടെക്ചറിൽ ഒരു ബൈനറി കംപൈൽ ചെയ്‌തിട്ടുണ്ട്, എന്നാൽ മെമ്മറി ഓപ്പറേഷനുകളിലൂടെ കോഡ് ബൈനേറിയനിൽ നിന്നോ സ്റ്റാക്കിൽ നിന്നോ 2-ബിറ്റ് അഡ്രസ് സ്‌പെയ്‌സിന്റെ മുകളിലെ 32 ജിബിയിൽ മറ്റെവിടെയെങ്കിലുമോ കയറുന്നു. ബിനാരെന്റെ കാഴ്ചപ്പാടിൽ ഇത് വളരെ വലിയ ഫലമായ വിലാസത്തിലേക്ക് പ്രവേശിക്കുന്നു എന്നതാണ് പ്രശ്നം. ഇതിനെ എങ്ങനെ മറികടക്കാം?

അഡ്മിന്റെ വഴിയിൽ

ഞാൻ ഇത് പരീക്ഷിക്കുന്നത് അവസാനിപ്പിച്ചില്ല, പക്ഷേ എന്റെ ആദ്യത്തെ ചിന്ത "ഞാൻ 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