QEMU.js: איצט ערנסט און מיט וואַסם

אַמאָל אויף אַ צייַט איך באַשלאָסן פֿאַר שפּאַס באַווייַזן די ריווערסאַביליטי פון דעם פּראָצעס און לערנען ווי צו דזשענערייט דזשאַוואַסקריפּט (מער גענוי, Asm.js) פֿון מאַשין קאָד. QEMU איז אויסדערוויילט פֿאַר דער עקספּערימענט, און עטלעכע מאָל שפּעטער אַן אַרטיקל איז געווען געשריבן אויף הבר. אין די באַמערקונגען איך איז געווען אַדווייזד צו רימייק די פּרויעקט אין וועבאַססעמבלי, און אפילו פאַרלאָזן זיך כּמעט פאַרטיק איך האב עפעס נישט געוואלט די פראיעקט... די ארבעט איז געווען אנגעגאנגען, אבער זייער לאנגזאם, און יעצט, לעצטנס אין יענעם ארטיקל איז ארויס קאָמענטאַר אויף דער טעמע "אזוי ווי האט עס אַלע סוף?" אין ענטפער צו מיין דיטיילד ענטפער, איך געהערט "דאָס סאָונדס ווי אַן אַרטיקל." נו, אויב איר קענען, עס וועט זיין אַן אַרטיקל. אפֿשר עמעצער וועט געפֿינען עס נוציק. דער לייענער וועט לערנען עטלעכע פאקטן וועגן די פּלאַן פון באַקענדז פון 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, און זיי זענען נישט זייער קאַמפּאַטאַבאַל. פּלוצלינג עס פארקערט אויס אַז אַ דערלויבעניש קענען זיין פאַרריכטן עס עפעס (איך טאָן ניט וויסן: אפֿשר טוישן עס, אפֿשר צווייענדיק לייסאַנסינג, אפֿשר עפּעס אַנדערש ...). דאס האט מיר פארשטײט זיך געפרײט, װײל איך האב שוין צו יענער צײט געקוקט ביינערי פֿאָרמאַט וועב אַסעמבלי, און איך איז געווען עפעס טרויעריק און ינגקאַמפּראַכענסיבאַל. עס איז אויך געווען אַ ביבליאָטעק וואָס וואָלט פרעסן די יקערדיק בלאַקס מיט די יבערגאַנג גראַפיק, פּראָדוצירן די ביטעקאָדע, און אפילו לויפן עס אין די יבערזעצער זיך, אויב נייטיק.

דעמאָלט עס איז געווען מער אַ בריוו אויף די QEMU מיילינג רשימה, אָבער דאָס איז מער וועגן די קשיא, "ווער דאַרף עס סייַ ווי סייַ?" און עס איז פּלוצלינג, ע ס הא ט זי ך ארויסגעװיזן . אין אַ מינימום, איר קענען סקראַפּ צוזאַמען אַזאַ פּאַסאַבילאַטיז פון נוצן אויב עס אַרבעט מער אָדער ווייניקער געשווינד:

• לאָנטשינג עפּעס בילדונגקרייז אָן קיין ינסטאַלירונג
• ווירטואַליזאַטיאָן אויף יאָס, ווו, לויט רומאָרס, די בלויז אַפּלאַקיישאַן וואָס האט די רעכט צו קאָד דור אויף די פליען איז אַ JS מאָטאָר (איז דאָס אמת?)
• דעמאַנסטריישאַן פון מיני-אַס - איין-פלאָפּפּי, געבויט-אין, אַלע מינים פון פירמוואַרע, עטק ...

בלעטערער רונטימע פֿעיִקייטן

ווי איך שוין געזאגט, QEMU איז טייד צו מולטיטהרעאַדינג, אָבער דער בלעטערער טוט נישט האָבן עס. נו, דאָס איז, ניט ... אין ערשטער עס האט נישט עקסיסטירן אין אַלע, דעמאָלט וועבוואָרקערס ארויס - ווי ווייַט ווי איך פֿאַרשטיין, דאָס איז מולטיטהרעאַדינג באזירט אויף אָנזאָג גייט פארביי אָן שערד וועריאַבאַלז. געוויינטלעך, דאָס קריייץ באַטייטיק פּראָבלעמס ווען פּאָרטינג יגזיסטינג קאָד באזירט אויף די שערד זכּרון מאָדעל. דעמאלט , אונטער עפנטלעכ ע דרוק , אי ז ע ם אוי ך דורכגעפיר ט געװאר ן אונטער ן נאמען SharedArrayBuffers. עס איז געווען ביסלעכווייַז באַקענענ, זיי סעלאַברייטיד זייַן קאַטער אין פאַרשידענע בראַוזערז, דעמאָלט זיי סעלאַברייטיד די ניו יאָר, און דעמאָלט מעלטדאָוון ... נאָך וואָס זיי געקומען צו די מסקנא אַז פּראָסט אָדער פּראָסט די צייט מעזשערמאַנט, אָבער מיט די הילף פון שערד זכּרון און אַ פאָדעם ינקראַמאַנטינג די טאָמבאַנק, עס ס אַלע די זעלבע עס וועט אַרבעט אויס שיין אַקיעראַטלי. אַזוי מיר פאַרקריפּלט מולטיטהרעאַדינג מיט שערד זכּרון. עס מיינט אַז זיי שפּעטער ווענדן עס צוריק, אָבער, ווי עס איז געווארן קלאָר פון דער ערשטער עקספּערימענט, עס איז לעבן אָן עס, און אויב אַזוי, מיר וועלן פּרובירן צו טאָן עס אָן רילייינג אויף מולטיטהרעאַדינג.

די רגע שטריך איז די ימפּאָסיביליטי פון נידעריק-מדרגה מאַניפּיאַליישאַנז מיט דעם אָנלייגן: איר קענען נישט פשוט נעמען, ראַטעווען דעם קראַנט קאָנטעקסט און באַשטימען צו אַ נייַע מיט אַ נייַע אָנלייגן. די רופן אָנלייגן איז געראטן דורך די JS ווירטואַל מאַשין. עס וואָלט ויסקומען, וואָס איז די פּראָבלעם, זינט מיר נאָך באַשלאָסן צו פירן די ערשטע פלאָוז גאָר מאַניואַלי? דער פאַקט איז אַז בלאָק I / O אין QEMU איז ימפּלאַמענאַד דורך קאָראָוטינז, און דאָס איז ווו נידעריק-מדרגה אָנלייגן מאַניפּיאַליישאַנז וואָלט זיין נוציק. צומ גליק, Emscipten שוין כּולל אַ מעקאַניזאַם פֿאַר ייסינגקראַנאַס אַפּעריישאַנז, אפילו צוויי: אַסינסיפי и עמטערפּרעטער. דער ערשטער אַרבעט דורך אַ באַטייטיק בלאָוטינג אין די דזשענערייטאַד דזשאַוואַסקריפּט קאָד און איז ניט מער געשטיצט. די רגע איז די קראַנט "ריכטיג וועג" און אַרבעט דורך בייטעקאָד דור פֿאַר די געבוירן יבערזעצער. עס אַרבעט, פון קורס, סלאָולי, אָבער עס טוט נישט בלאָוטינג די קאָד. אמת, שטיצן פֿאַר קאָראָוטינעס פֿאַר דעם מעקאַניזאַם האט צו זיין קאַנטריביוטיד ינדיפּענדאַנטלי (עס זענען שוין געשריבן קאָראָוטינעס פֿאַר Asyncify און עס איז געווען אַן ימפּלאַמענטיישאַן פון בעערעך דער זעלביקער API פֿאַר Emterpreter, איר נאָר דאַרפֿן צו פאַרבינדן זיי).

אין דער מאָמענט, איך האָבן נישט נאָך געראטן צו שפּאַלטן דעם קאָד אין איין קאַמפּיילד אין WASM און ינטערפּראַטאַד ניצן Emterpreter, אַזוי בלאָק דעוויסעס טאָן ניט אַרבעט נאָך (זען אין דער ווייַטער סעריע, ווי זיי זאָגן ...). אַז איז, אין די סוף איר זאָל באַקומען עפּעס ווי דעם מאָדנע לייערד זאַך:

• ינטערפּראַטאַד בלאָק איך / אָ. נו, האָט איר טאַקע דערוואַרטן עמיאַלייטיד NVMe מיט געבוירן פאָרשטעלונג? 🙂
• סטאַטיקלי קאַמפּיילד הויפּט QEMU קאָד (איבערזעצער, אנדערע עמיאַלייטיד דעוויסעס, אאז"ו ו)
• דינאַמיקאַללי קאַמפּיילד גאַסט קאָד אין WASM

פֿעיִקייטן פון QEMU קוואלן

ווי איר מיסטאָמע שוין געסט, די קאָד פֿאַר עמיאַלייטינג גאַסט אַרקאַטעקטשערז און די קאָד פֿאַר דזשענערייטינג באַלעבאָס מאַשין ינסטראַקשאַנז זענען אפגעשיידט אין QEMU. אין פאַקט, עס איז אפילו אַ ביסל טריקיער:

• עס זענען גאַסט אַרקאַטעקטשערז
• עס יז פאַראַן אַקסעלערייטערז, ניימלי, KVM פֿאַר ייַזנוואַרג ווירטואַליזאַטיאָן אויף לינוקס (פֿאַר גאַסט און באַלעבאָס סיסטעמען קאַמפּאַטאַבאַל מיט יעדער אנדערער), TCG פֿאַר דזשיט קאָד דור ערגעץ. סטאַרטינג מיט QEMU 2.9, שטיצן פֿאַר די HAXM ייַזנוואַרג ווירטואַליזאַטיאָן נאָרמאַל אויף Windows ארויס (די דעטאַילס)
• אויב TCG איז געניצט אלא ווי ייַזנוואַרג ווירטואַליזאַטיאָן, עס האט אַ באַזונדער קאָד דור שטיצן פֿאַר יעדער באַלעבאָס אַרקאַטעקטשער, ווי געזונט ווי פֿאַר די וניווערסאַל יבערזעצער
• ... און אַרום אַלע דעם - עמיאַלייטיד פּעריפעראַלס, באַניצער צובינד, מיגראַטיאָן, רעקאָרד-ריפּליי, עטק.

אגב, האט איר וויסן: QEMU קענען עמיאַלייט ניט בלויז די גאנצע קאָמפּיוטער, אָבער אויך די פּראַסעסער פֿאַר אַ באַזונדער באַניצער פּראָצעס אין דער באַלעבאָס קערן, וואָס איז געניצט, למשל, דורך די AFL Fuzzer פֿאַר ביינערי ינסטראַמענטיישאַן. טאָמער עמעצער וואָלט ווי צו אַריבערפירן דעם מאָדע פון ​​אָפּעראַציע פון ​​QEMU צו JS? 😉

ווי רובֿ לאַנג-שטייענדיק פריי ווייכווארג, QEMU איז געבויט דורך די רופן configure и make. זאל ס זאָגן איר באַשליסן צו לייגן עפּעס: אַ TCG באַקענד, פאָדעם ימפּלאַמענטיישאַן, עפּעס אַנדערש. דו זאלסט נישט קאַמיש צו זיין צופרידן / כאָראַפייד (ונדערליין ווי צונעמען) אין די ויסקוק פון קאַמיונאַקייטינג מיט אַוטאָקאָנף - אין פאַקט, configure QEMU ס איז משמעות זיך-געשריבן און איז נישט דזשענערייטאַד פון עפּעס.

וועבאַססעמבלי

אַזוי וואָס איז די זאַך גערופן וועבאַססעמבלי (אַקאַ וואַסם)? דאָס איז אַ פאַרבייַט פֿאַר Asm.js, ניט מער פּריטענדינג צו זיין גילטיק דזשאַוואַסקריפּט קאָד. אויף די פאַרקערט, עס איז ריין ביינערי און אָפּטימיזעד, און אפילו פשוט שרייַבן אַ גאַנץ נומער אין עס איז נישט זייער פּשוט: פֿאַר קאַמפּאַקטנאַס, עס איז סטאָרד אין דעם פֿאָרמאַט. LEB128.

איר קען האָבן געהערט וועגן די רעלאָפּינג אַלגערידאַם פֿאַר Asm.js - דאָס איז די רעסטעריישאַן פון "הויך-מדרגה" לויפן קאָנטראָל אינסטרוקציעס (דאָס איז, אויב-דעמאָלט אַנדערש, לופּס, אאז"ו ו), פֿאַר וואָס JS ענדזשאַנז זענען דיזיינד, פֿון די נידעריק-מדרגה LLVM IR, נעענטער צו די מאַשין קאָד עקסאַקיוטאַד דורך די פּראַסעסער. געוויינטלעך, די ינטערמידייט פאַרטרעטונג פון QEMU איז נעענטער צו די רגע. עס וואָלט ויסקומען אַז דאָ עס איז, ביטעקאָדע, דער סוף פון די מאַטערן ... און דעמאָלט עס זענען בלאַקס, אויב-דעמאָלט-אַנדערש און לופּס!..

און דאָס איז אן אנדער סיבה וואָס Binaryen איז נוציק: עס קענען געוויינטלעך אָננעמען הויך-מדרגה בלאַקס נאָענט צו וואָס וואָלט זיין סטאָרד אין WASM. אָבער עס קענען אויך פּראָדוצירן קאָד פון אַ גראַפיק פון יקערדיק בלאַקס און טראַנזישאַנז צווישן זיי. נו, איך האב שוין געזאגט אַז עס כיידז די וועבאַססעמבלי סטאָרידזש פֿאָרמאַט הינטער די באַקוועם C / C ++ אַפּי.

TCG (Tiny Code Generator)

GTC איז ערידזשנאַלי באַקענד פֿאַר די קאַמפּיילער C. דערנאָך, משמעות, עס קען נישט וויטסטאַנד די פאַרמעסט מיט GCC, אָבער אין די סוף עס געפֿונען זיין אָרט אין QEMU ווי אַ קאָד דור מעקאַניזאַם פֿאַר דער באַלעבאָס פּלאַטפאָרמע. עס איז אויך אַ TCG באַקענד וואָס דזשענערייץ עטלעכע אַבסטראַקט ביטעקאָדע, וואָס איז גלייך עקסאַקיוטאַד דורך די יבערזעצער, אָבער איך באַשלאָסן צו ויסמיידן ניצן עס דאָס מאָל. אָבער, דער פאַקט אַז אין QEMU עס איז שוין מעגלעך צו געבן די יבערגאַנג צו די דזשענערייטאַד טב דורך די פונקציע tcg_qemu_tb_exec, עס איז געווען זייער נוציק פֿאַר מיר.

צו לייגן אַ נייַע TCG באַקענד צו QEMU, איר דאַרפֿן צו שאַפֿן אַ סובדירעקטאָרי tcg/<имя архитектуры> (אין דעם פאַל, tcg/binaryen), און עס כּולל צוויי טעקעס: tcg-target.h и tcg-target.inc.c и פאָרשרייַבן עס ס אַלע וועגן configure. איר קענען שטעלן אנדערע טעקעס דאָרט, אָבער, ווי איר קענען טרעפן פֿון די נעמען פון די צוויי, זיי וועלן ביידע זיין אַרייַנגערעכנט ערגעץ: איינער ווי אַ רעגולער כעדער טעקע (עס איז אַרייַנגערעכנט אין tcg/tcg.h, און אַז איינער איז שוין אין אנדערע טעקעס אין די דירעקטעריז tcg, accel און ניט בלויז), די אנדערע - בלויז ווי אַ קאָד סניפּאַט אין tcg/tcg.c, אָבער עס האט אַקסעס צו זייַן סטאַטיק פאַנגקשאַנז.

איך באַשלאָסן אַז איך וואָלט פאַרברענגען צו פיל צייט אויף דיטיילד ינוועסטאַגיישאַנז פון ווי עס אַרבעט, איך פשוט קאַפּיד די "סקעלעטאָנס" פון די צוויי טעקעס פֿון אן אנדער באַקענד ימפּלאַמענטיישאַן, האָנעסטלי ינדאַקייטינג דעם אין די דערלויבעניש כעדער.

טעקע tcg-target.h כּולל דער הויפּט סעטטינגס אין די פאָרעם #define-ס:

• ווי פילע רעדזשיסטערז און וואָס ברייט זענען אויף די ציל אַרקאַטעקטשער (מיר האָבן ווי פילע ווי מיר ווילן, ווי פילע ווי מיר ווילן - די קשיא איז מער וועגן וואָס וועט זיין דזשענערייטאַד אין מער עפעקטיוו קאָד דורך דעם בלעטערער אויף די "גאַנץ ציל" אַרקאַטעקטשער ...)
• אַליינמאַנט פון באַלעבאָס אינסטרוקציעס: אויף קס 86 און אפילו אין TCI, אינסטרוקציעס זענען נישט אַליינד אין אַלע, אָבער איך וועל שטעלן אין די קאָד באַפער נישט אינסטרוקציעס אין אַלע, אָבער אָנווייַז צו Binaryen ביבליאָטעק סטראַקטשערז, אַזוי איך וועל זאָגן: 4 ביטעס
• וואָס אַפּשאַנאַל אינסטרוקציעס די באַקענד קענען דזשענערייט - מיר אַרייַננעמען אַלץ מיר געפֿינען אין Binaryen, לאָזן די אַקסעלעראַטאָר ברעכן די מנוחה אין סימפּלער אָנעס זיך
• וואָס איז די דערנענטערנ גרייס פון די TLB קאַש געבעטן דורך די באַקענד. דער פאַקט איז אַז אין QEMU אַלץ איז ערנסט: כאָטש עס זענען העלפּער פאַנגקשאַנז וואָס דורכפירן מאַסע / קראָם גענומען אין חשבון די גאַסט MMU (וואו וואָלט מיר זיין אָן עס איצט?), זיי ראַטעווען זייער איבערזעצונג קאַש אין די פאָרעם פון אַ סטרוקטור, די פּראַסעסינג פון וואָס איז באַקוועם צו ימבעד גלייַך אין בראָדקאַסט בלאַקס. די קשיא איז, וואָס פאָטאָ אין דעם סטרוקטור איז מערסט יפישאַנטלי פּראַסעסט דורך אַ קליין און שנעל סיקוואַנס פון קאַמאַנדז?
• דאָ איר קענען טוויק די ציל פון איין אָדער צוויי רעזערווירט רעדזשיסטערז, געבן טב רופן דורך אַ פֿונקציע און אָפּטיאָנאַללי באַשרייַבן עטלעכע קליין inline-פונקציעס ווי flush_icache_range (אָבער דאָס איז נישט אונדזער פאַל)

טעקע tcg-target.inc.c, פון קורס, איז יוזשאַוואַלי פיל גרעסערע אין גרייס און כּולל עטלעכע מאַנדאַטאָרי פאַנגקשאַנז:

• יניטיאַליזאַטיאָן, אַרייַנגערעכנט ריסטריקשאַנז אויף וואָס ינסטראַקשאַנז קענען אַרבעטן אויף וואָס אָפּעראַנדז. בלייטאַנטלי קאַפּיד דורך מיר פון אן אנדער באַקענד
• פונקציע וואָס נעמט איין ינערלעך ביטעקאָדע לימעד
• איר קענען אויך שטעלן אַגזיליערי פאַנגקשאַנז דאָ, און איר קענען אויך נוצן סטאַטיק פאַנגקשאַנז פֿון tcg/tcg.c

פֿאַר זיך, איך אויסדערוויילט די פאלגענדע סטראַטעגיע: אין די ערשטער ווערטער פון די ווייַטער איבערזעצונג בלאָק, איך געשריבן פיר פּוינטערז: אַ אָנהייב צייכן (אַ זיכער ווערט אין דער געגנט 0xFFFFFFFF, וואָס באשלאסן די קראַנט שטאַט פון די טב), קאָנטעקסט, דזשענערייטאַד מאָדולע און מאַגיש נומער פֿאַר דיבאַגינג. אין ערשטער די מאַרק איז געווען שטעלן אין 0xFFFFFFFF - nווו n - אַ קליין positive נומער, און יעדער מאָל עס איז געווען עקסאַקיוטאַד דורך די יבערזעצער עס געוואקסן מיט 1. ווען עס ריטשט 0xFFFFFFFE, זאַמלונג איז פארגעקומען, דער מאָדולע איז געראטעוועט אין די פונקציע טיש, ימפּאָרטיד אין אַ קליין "לאַונטשער", אין וואָס די דורכפירונג איז געווען פֿון tcg_qemu_tb_exec, און דער מאָדולע איז אַוועקגענומען פון QEMU זכּרון.

צו פּאַראַפראַז די קלאַסיקס, "קרוטש, ווי פיל איז ינטערטוויינד אין דעם געזונט פֿאַר די פּראָגער ס האַרץ ...". אָבער, דער זכּרון איז געווען ליקינג ערגעץ. דערצו, עס איז געווען זיקאָרן געראטן דורך QEMU! איך האב געהאט א קאוד אז ווען מען שרייבט די קומענדיגע אינסטרוקציע (נו, דאס הייסט א צייכער) האט מען אויסגעמעקט דעם וואס זיין לינק איז געווען פריער אויף דעם פלאץ, אבער דאס האט נישט געהאלפן. אַקטואַללי, אין די סימפּלאַסט פאַל, QEMU אַלאַקייץ זכּרון ביי סטאַרטאַפּ און שרייבט די דזשענערייטאַד קאָד דאָרט. ווען דער באַפער לויפט אויס, די קאָד איז ארלנגעווארפן און דער ווייַטער איינער הייבט צו זיין געשריבן אין זייַן אָרט.

נאָך געלערנט דעם קאָד, איך איינגעזען אַז דער קונץ מיט די מאַגיש נומער ערלויבט מיר נישט צו פאַרלאָזן אויף קופּע צעשטערונג דורך פריי עפּעס פאַלש אויף אַ אַנינישיאַלייזד באַפער אויף דער ערשטער פאָרן. אבער ווער רירייט די באַפער צו בייפּאַס מיין פֿונקציע שפּעטער? ווי די עמסקריפּטען דעוועלאָפּערס רעקאָמענדירן, ווען איך געלאפן אין אַ פּראָבלעם, איך טראַנספּאָרטאַד די ריזאַלטינג קאָד צוריק צו די געבוירן אַפּלאַקיישאַן, שטעלן מאָזיללאַ רעקאָרד-רעפּלייַ אויף עס ... אין אַלגעמיין, אין די סוף איך איינגעזען אַ פּשוט זאַך: פֿאַר יעדער בלאָק, א struct TranslationBlock מיט זייַן באַשרייַבונג. טרעפן ווו ... אַז ס רעכט, פּונקט איידער די בלאָק רעכט אין די באַפער. איך האָב דאָס איינגעזען, איך באַשלאָסן צו פאַרלאָזן ניצן קראַטשיז (לפּחות עטלעכע), און פשוט וואַרפן אויס די מאַגיש נומער, און טראַנספערד די רוען ווערטער צו struct TranslationBlock, קריייטינג אַ איין לינגקט רשימה וואָס קענען זיין געשווינד דורכגעגאנגען ווען די איבערזעצונג קאַש איז באַשטעטיק, און פריי זיקאָרן.

עטלעכע קראַטשיז בלייַבן: פֿאַר בייַשפּיל, אנגעצייכנט פּוינטערז אין די קאָד באַפער - עטלעכע פון ​​זיי זענען פשוט BinaryenExpressionRef, דאָס איז, זיי קוקן אין די אויסדרוקן וואָס דאַרפֿן צו זיין לינעאַרלי שטעלן אין די דזשענערייטאַד יקערדיק בלאָק, טייל איז דער צושטאַנד פֿאַר יבערגאַנג צווישן BBs, טייל איז ווו צו גיין. נו, עס זענען שוין צוגעגרייט בלאַקס פֿאַר רעלאָפּער וואָס דאַרפֿן צו זיין פארבונדן לויט די באדינגונגען. צו ויסטיילן זיי, די האַשאָרע איז געניצט אַז זיי זענען אַלע אַליינד מיט בייַ מינדסטער פיר ביטעס, אַזוי איר קענען בעשאָלעם נוצן די קלענסטער באַטייטיק צוויי ביטן פֿאַר די פירמע, איר נאָר דאַרפֿן צו געדענקען צו באַזייַטיקן עס אויב נייטיק. דורך דעם וועג, אַזאַ לאַבעלס זענען שוין געניצט אין QEMU צו אָנווייַזן די סיבה פֿאַר אַרויסגאַנג די TCG שלייף.

ניצן Binaryen

מאָדולעס אין וועבאַססעמבלי אַנטהאַלטן פאַנגקשאַנז, יעדער פון וואָס כּולל אַ גוף, וואָס איז אַן אויסדרוק. עקספּרעססיאָנס זענען ונאַרי און ביינערי אַפּעריישאַנז, בלאַקס קאַנסיסטינג פון רשימות פון אנדערע אויסדרוקן, קאָנטראָל לויפן, אאז"ו ו. ווי איך שוין געזאגט, קאָנטראָל לויפן דאָ איז אָרגאַניזירט פּונקט ווי הויך-מדרגה צווייגן, לופּס, פֿונקציע רופט, אאז"ו ו. אַרגומענטן צו פאַנגקשאַנז זענען נישט דורכגעגאנגען אויף די אָנלייגן, אָבער בפירוש, פּונקט ווי אין JS. עס זענען אויך גלאבאלע וועריאַבאַלז, אָבער איך האָבן נישט געוויינט זיי, אַזוי איך וועל נישט זאָגן איר וועגן זיי.

פאַנגקשאַנז אויך האָבן היגע וועריאַבאַלז, געציילט פֿון נול, פון טיפּ: int32 / int64 / float / double. אין דעם פאַל, דער ערשטער n היגע וועריאַבאַלז זענען די אַרגומענטן דורכגעגאנגען צו די פֿונקציע. ביטע טאָן אַז כאָטש אַלץ דאָ איז נישט גאָר נידעריק-מדרגה אין טערמינען פון קאָנטראָל לויפן, ינטאַדזשערז נאָך טאָן ניט האָבן די "געחתמעט / אַנסיינד" אַטריביוט: ווי די נומער ביכייווז דעפּענדס אויף די אָפּעראַציע קאָד.

אין אַלגעמיין, Binaryen גיט פּשוט C-אַפּי: איר שאַפֿן אַ מאָדולע, אין אים שאַפֿן אויסדרוקן - ונאַרי, ביינערי, בלאַקס פון אנדערע אויסדרוקן, קאָנטראָל לויפן, עטק. דערנאָך איר מאַכן אַ פֿונקציע מיט אַן אויסדרוק ווי זייַן גוף. אויב איר, ווי מיר, האָבן אַ נידעריק-מדרגה יבערגאַנג גראַפיק, די רעלאָפּער קאָמפּאָנענט וועט העלפן איר. ווי ווייט איך פארשטיי איז עס מעגלעך צו נוצן הויך-מדרגה קאָנטראָל פון די דורכפירונג לויפן אין אַ בלאָק, ווי לאַנג ווי עס גייט נישט ווייַטער פון די באַונדריז פון די בלאָק - דאָס איז, עס איז מעגלעך צו מאַכן ינערלעך שנעל דרך / פּאַמעלעך וועג בראַנטשינג אין די געבויט-אין 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.

דורך די וועג, דעמאָ (דערווייַל מיט אַ מערקי דערלויבעניש) אַרבעט נאָר גוט אין Firefox. קראָום דעוועלאָפּערס זענען געווען עפעס נישט גרייט צו דעם פאַקט אַז עמעצער וואָלט וועלן צו שאַפֿן מער ווי אַ טויזנט ינסטאַנסיז פון וועבאַססעמבלי מאַדזשולז, אַזוי זיי פשוט אַלאַקייטיד אַ גיגאבייט פון ווירטואַל אַדרעס פּלאַץ פֿאַר יעדער ...

אַז ס אַלע פֿאַר איצט. טאָמער עס וועט זיין אן אנדער אַרטיקל אויב עמעצער איז אינטערעסירט. נאַמעלי, עס בלייבט בייַ מינדסטער בלויז מאַכן בלאָק דעוויסעס אַרבעט. עס קען אויך מאַכן זינען צו מאַכן די זאַמלונג פון וועבאַססעמבלי מאַדזשולז ייסינגקראַנאַס, ווי איז קאַסטאַמערי אין די JS וועלט, ווייַל עס איז נאָך אַן יבערזעצער וואָס קענען טאָן דאָס אַלץ ביז די געבוירן מאָדולע איז גרייט.

צום סוף אַ רעטעניש: איר האָט צונויפגעשטעלט אַ ביינערי אויף אַ 32-ביסל אַרקאַטעקטשער, אָבער די קאָד, דורך זכּרון אַפּעריישאַנז, קליימז פֿון Binaryen, ערגעץ אויף די אָנלייגן אָדער ערגעץ אַנדערש אין דער אויבערשטער 2 גיגאבייט פון די 32-ביסל אַדרעס פּלאַץ. די פּראָבלעם איז אַז פֿון Binaryen ס פונט פון מיינונג, דאָס איז אַקסעס צו אַ גרויס רעזולטאַט אַדרעס. ווי צו באַקומען אַרום דעם?

אין די אַדמיניסטראַטיווע וועג

איך האָב נישט טעסטעד דעם, אָבער מיין ערשטער געדאַנק איז געווען "וואָס אויב איך אינסטאַלירן 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