Գնահատել նախագիծը
← Բոլոր հրապարակումները

Երկար ճանապարհ. ինչպես է մեքենան մեկնաբանում բայթկոդը

Խորքային հայացք այն մասին, թե ինչպես է JVM-ը մեկնաբանում և կոմպիլացնում Java բայթկոդը JIT կոմպիլյացիայի մի քանի մակարդակներով՝ ինտերպրետատորից մինչև C1 և C2 կոմպիլյատորներ։ Իմացեք, թե ինչպես են այս մեխանիզմները բարձրացնում հավելվածի արտադրողականությունն ու արդյունավետությունը։

11 րոպե
JavaJVMJava Internals

Ես նախկինում լսել էի, որ JIT (Just In Time) կոմպիլյատորը կարող է բայթկոդը կոմպիլացնել մի քանի մակարդակներով, բայց երբեք իսկապես չէի մտածել, թե դա գործնականում ինչ է նշանակում։ Հոկտեմբերի կեսերին մասնակցեցի մի կոնֆերանսի և հնարավորություն ունեցա լսել ‘lock-free programming’-ի մասին զեկույց։ Այդ զեկույցում խոսողները համառոտ անդրադարձան JVM-ի ներքին կառուցվածքին, ինչը ինձ ցանկություն առաջացրեց թեման ավելի խորը ուսումնասիրել։ Քանի որ ուրիշներին ինչ-որ բան բացատրելը լավագույն միջոցներից մեկն է ստուգելու՝ արդյոք իսկապես հասկանում ես այն, որոշեցի գրել այս հոդվածը։

Աստիճանավոր կոմպիլյացիա (Tiered compilation)

Java-ի և C++-ի նման լեզուների միջև առանցքային տարբերությունը կայանում է նրանում, թե ինչպես են դրանք կոմպիլացվում։ C++ կոմպիլյատորը կոդը ուղղակի վերածում է մեքենայական կոդի, որը CPU-ն կարող է կատարել։ Java-ն, ընդհակառակը, իր կոդը կոմպիլացնում է միջանկյալ ձևաչափի, որը կոչվում է բայթկոդ։ CPU-ն չի կարող այս բայթկոդը ուղղակի կատարել. այն լրացուցիչ մշակում է պահանջում։ JVM-ը այն հավելվածն է, որը այս բայթկոդը վերածում է մեքենայական կոդի, որպեսզի CPU-ն կարողանա այն կատարել։

Հիշեք, որ կոդը, որ գրում ենք ցանկացած JVM-համատեղելի լեզվով, ծառայում է որպես բաղադրատոմս, որը նկարագրում է, թե ինչպես ենք ուզում, որ մեր ծրագիրը աշխատի։

JVM-ը կարող է մեր բայթկոդը կոմպիլացնել հինգ տարբեր մակարդակներով։ Ահա պատկեր, որը դա ցույց է տալիս.

JVM-ում կոմպիլյացիայի հինգ մակարդակները

Մակարդակների տարբերությունը ցույց տալու համար որպես օրինակ կօգտագործեմ շատ պարզ մեթոդ։

Բայթկոդ (.class)

Ահա Java-ում սահմանված մեթոդը.

private static int resolveNumber(int i) {
    if (i < 20000) return i;
    else return i * 2;
}

Երբ այն կոմպիլացվում է, ստացված բայթկոդը կարող ենք ստուգել այս հրամանով.

javap -c -p target/classes/org/zygiert/Main.class
  • javap-ը Java Class File Disassembler-ն է, որը մատակարարվում է JDK-ի հետ։
  • -c տարբերակը տպում է դիզասեմբլացված կոդը։
  • -v տարբերակը ստիպում է, որ private մեթոդները նույնպես երևան (այս հատվածը Main դասի մի մասն է)։

Ստացված բայթկոդը JVM գործողության կոդերի հաջորդականություն է, որը նկարագրում է, թե որ գործողությունները պետք է կատարվեն։ Սա մեթոդի բայթկոդային ներկայացումն է.

         0: iload_0
         1: sipush        20000
         4: if_icmpge     9
         7: iload_0
         8: ireturn
         9: iload_0
        10: iconst_2
        11: imul
        12: ireturn

Ահա թե ինչ է իրականում տեղի ունենում.

  1. iload_0-ն լոկալ փոփոխականից ամբողջ թիվ է դնում stack-ի վրա։
  2. sipush-ը stack-ի վրա դնում է 20000 կարճ ամբողջ թիվը։
  3. if_icmpge-ը համեմատում է երկու ամբողջ արժեքները։ Երբ առաջին ամբողջ թիվը մեծ է կամ հավասար 20000-ի, այն անցնում է 9 բայթ շեղման (offset) վրա գտնվող հրահանգին։ Հակառակ դեպքում կատարումը շարունակվում է հաջորդ հրահանգով։

Երբ ամբողջ թիվը փոքր է 20000-ից.

  • iload_0-ն պարամետրը կրկին դնում է stack-ի վրա։
  • ireturn-ը stack-ից վերադարձնում է ամբողջ թիվը։

Երբ ամբողջ թիվը մեծ է կամ հավասար 20000-ի.

  • iload_0-ն պարամետրը կրկին դնում է stack-ի վրա։
  • iconst_2-ը stack-ի վրա դնում է 2 հաստատուն ամբողջ թիվը։
  • imul-ը բազմապատկում է stack-ի վերևի երկու ամբողջ թվերը և արտադրյալը թողնում stack-ի վրա։
  • ireturn-ը stack-ից վերադարձնում է ստացված ամբողջ թիվը։

Արագ պարզաբանում. ձախ կողմի թվերը հրահանգների համարներ չեն, այլ բայթ շեղումներ։ Օրինակ՝ 0 բայթ շեղման վրա գտնվող iload_0 հրահանգը իր գործողության կոդի համար վերցնում է ընդամենը 1 բայթ։ Ահա թե ինչու sipush գործողության կոդը գալիս է անմիջապես դրանից հետո՝ 1 բայթ շեղման վրա։ sipush հրահանգը վերցնում է 3 բայթ. 1-ը՝ գործողության կոդի համար, և ևս 2-ը՝ stack-ի վրա դրվող կարճ ամբողջ թվի համար։ Ահա թե ինչու if_icmpge գործողության կոդը գտնվում է 4 բայթ շեղման վրա։

Սրանք հասանելի բայթկոդային գործողության կոդերից միայն մի քանիսն են։ Ամբողջական ցանկը գտնվում է JVM specification-ում։ Սակայն հիշեք, որ սա ընդամենը մեր կոդի միջանկյալ ներկայացումն է, որը դեռ պետք է վերածվի մեքենայական կոդի։ Դա ինտերպրետատորի գործն է։

Ինտերպրետատոր (Interpreter)

Այսօր JVM-ը հենվում է template ինտերպրետատորի վրա, որը հավելվածի մեկնարկի ժամանակ յուրաքանչյուր բայթկոդային հրահանգ վերածում է մեքենայական կոդի։ Սա տեղի է ունենում հավելվածի յուրաքանչյուր գործարկման ժամանակ։ Երբ հավելվածը սկսվում է, template ինտերպրետատորը յուրաքանչյուր բայթկոդային հրահանգի համար արտադրում է բնիկ կոդ՝ հաշվի առնելով այնպիսի գործոններ, ինչպիսիք են CPU ճարտարապետությունը և հիմքում ընկած օպերացիոն համակարգը։ Այնուհետև բնիկ կոդը պահվում է code cache-ում։

Տեսնելու համար, թե որքան ժամանակ է տևում բնիկ կոդի գեներացիան, գործարկեք այս հրամանը.

java -Xlog:startuptime -jar target/app.jar 10

Տպված լոգը կպարունակի այսպիսի մի տող.

[0.019s][info][startuptime] Interpreter generation, 0.0014898 secs

Ակնհայտ է, որ ինտերպրետատորի գեներացումը բավականին արագ է։

Այդ պահից JVM-ն ունի կոմպիլացված բնիկ կոդ՝ կապված յուրաքանչյուր բայթկոդային հրահանգի հետ։ Այսպես, երբ մեթոդը աշխատում է այս վիճակում, JVM-ը անցնում է բայթկոդով և յուրաքանչյուր հրահանգի համար կատարում է համապատասխան բնիկ կոդը։ Սա թույլ է տալիս մեր հավելվածին բավականին արագ սկսել, բայց ամենաարդյունավետ մոտեցումը չէ։

Ինտերպրետատորի արտադրած բնիկ կոդը ստուգելու համար գործարկեք այս հրամանը.

java -XX:+UnlockDiagnosticVMOptions -XX:+PrintInterpreter -jar target/app.jar 10

Ելքը երկար է, բայց բնիկ կոդի յուրաքանչյուր մաս պիտակավորված է իր գործողության կոդի անունով, ուստի ձեզ անհրաժեշտը գտնելը ավելի հեշտ է։ Ահա որպես օրինակ iload_0 գործողության կոդը.

iload_0  26 iload_0  [0x000071666f9465e0, 0x000071666f946628]  72 bytes
[MachCode]
  0x000071666f9465e0: 4883 ec08 | c5fa 1104 | 24eb 1f48 | 83ec 10c5 | fb11 0424 | eb14 4883 | ec10 4889 | 0424 48c7 
  0x000071666f946600: 4424 0800 | 0000 00eb | 0150 418b | 0641 0fb6 | 5d01 49ff | c549 ba80 | 1237 8666 | 7100 0041 
  0x000071666f946620: ff24 da0f | 1f44 0000 
[/MachCode]

Արժե նաև նշել, որ JDK-ն դեռ պարունակում է C++ ինտերպրետատոր, թեև JDK-ի ժամանակակից տարբերակները այն լռելյայն չեն օգտագործում։

C1 կոմպիլյատոր

C1 կոմպիլյատորը, որը կոչվում է նաև client կոմպիլյատոր, JIT կոմպիլյացիայի գործընթացի մասն է։ Այն միանում է, երբ JVM-ի պրոֆիլավորման մեխանիզմը նկատում է, որ որոշ մեթոդներ հաճախ են աշխատում։ C1 կոմպիլյատորը աշխատում է երեք տարբեր մակարդակներով։

Մակարդակ 1

Այս մակարդակը նախատեսված է չնչին մեթոդների համար, ինչպիսիք են getter-ները, setter-ները կամ հաստատուն արժեքներ վերադարձնող մեթոդները։ Նման մեթոդները հետագայում օպտիմիզացնելով ոչինչ չես շահի։ Այս մակարդակում պրոֆիլավորման տվյալներ չեն հավաքվում, քանի որ դրանք անհրաժեշտ չեն։

Մակարդակ 2

Այս մակարդակում կոմպիլյատորը հենվում է մեթոդի մասին հիմնական պրոֆիլավորման տեղեկատվության վրա։ Դրա պատճառով կոմպիլացված մեթոդը ավելի փոքր է, քան Tier 3-ում կոմպիլացվածը։ Սովորաբար, երբ JVM-ը նկատում է, որ մեթոդը hot է, այն կոմպիլացնում է Tier 3-ի, իսկ հետո՝ Tier 4-ի։

Արժե բացատրել, թե ինչն է մեթոդը դարձնում hot։ Մեթոդը hot կարող է դառնալ երկու եղանակով.

  1. Դրա կանչերի քանակը գերազանցում է TierXInvocationThreshold-ը՝ բազմապատկած CompileThresholdScaling-ով։
  2. Դրա կանչերի քանակը գերազանցում է TierXMinInvocationThreshold-ը՝ բազմապատկած CompileThresholdScaling-ով, և դրա կանչերի քանակը գումարած ներսում ցիկլի իտերացիաների քանակը գերազանցում է TierXCompileThreshold-ը՝ բազմապատկած CompileThresholdScaling-ով։

Եթե Tier 4 կոմպիլյացիայի հերթը չափազանց երկար է, սակայն, սպասելը կարող է չարդարացնել իրեն։ Դրան գումարած՝ մեթոդը Tier 3-ում կոմպիլացված թողնելը կարող է անարդյունավետ լինել լրացուցիչ պրոֆիլավորման տվյալներից առաջացող լրացուցիչ չափի և բարդության պատճառով։ Այս իրավիճակներում մեթոդը կարող է նորից կոմպիլացվել Tier 2-ի, իսկ ավելի ուշ՝ կրկին Tier 3-ի և ապա Tier 4-ի։

Մակարդակ 3

Երբ մեթոդը ճանաչվում է որպես hot, այն սովորաբար կոմպիլացվում է Tier 3-ի, որը կրում է լրիվ պրոֆիլավորման տվյալներ։ Այս մակարդակը հաճախ ընդամենը միջանկյալ քայլ է Tier 4-ի ճանապարհին։ Ինչպես վերևում նշվեց, սակայն, որոշ դեպքերում մեթոդը կարող է կոմպիլացվել Tier 2-ի՝ անմիջապես Tier 4-ի անցնելու փոխարեն։

Կոմպիլացված կոդի մանրամասների ստուգում

Ավելի վաղ ասացի, որ C1 կոմպիլյատորով կոմպիլացված մեթոդները տարբերվում են չափով և այն բանով, թե որքան պրոֆիլավորման տվյալներ են ստանում։ Այժմ տեսնենք դա գործնականում։

JVM-ին կոմպիլյացիան տվյալ մակարդակում դադարեցնելու և մեթոդի կոմպիլյացիայի մասին տեղեկատվություն տպելու համար կարող եք թիրախավորել C1 մակարդակը այս հրամանով.

java -XX:+PrintCompilation -XX:TieredStopAtLevel=1 -jar target/app.jar 15000
  • -XX:+PrintCompilation-ը միացնում է կոմպիլյացիայի մանրամասների տպումը։
  • -XX:TieredStopAtLevel=1-ը JVM-ին ասում է կոմպիլյացիան դադարեցնել Tier 1-ում։

Թվարկված մեթոդների մեջ կտեսնեք resolveNumber մեթոդը.

46   20       1       org.zygiert.Main::resolveNumber (13 bytes)
  • 46-ը ծրագրի մեկնարկից անցած ժամանակն է միլիվայրկյաններով։
  • 20-ը կոմպիլյացիայի ID-ն է։
  • 1-ը կոմպիլյացիայի մակարդակն է (Tier)։
  • org.zygiert.Main::resolveNumber-ը մեթոդի ստորագրությունն է։
  • (13 bytes)-ը ցույց է տալիս բայթկոդի չափը։

Այժմ, երբ ստիպեցինք C1 կոմպիլյատորին մեր մեթոդը կոմպիլացնել Tier 1-ի, հաջորդ քայլը նայելն է այն բնիկ կոդին, որն իրականում արտադրվել է դրա համար, գումարած մի քանի լրացուցիչ մանրամասներ։ Դրա համար կօգտագործեմ երկու JVM տարբերակ.

  • -XX:+UnlockDiagnosticVMOptions, որը միացնում է JVM-ի ախտորոշիչ տարբերակները։
  • -XX:+PrintAssembly, որը տպում է բնիկ կոդը։

Ահա ամբողջական հրամանը.

java -XX:+UnlockDiagnosticVMOptions -XX:+PrintAssembly -XX:TieredStopAtLevel=1 -jar target/app.jar 15000

Ելքը մեծ է, բայց դրա մեջ կարող եք գտնել resolveNumber մեթոդը։ Ահա թե ինչ տեսք ունի տպված մանրամասների սկիզբը.

Compiled method (c1) 122   20       1       org.zygiert.Main::resolveNumber (13 bytes)
 total in heap  [0x0000719a289a3888,0x0000719a289a3a60] = 472
 main code      [0x0000719a289a3980,0x0000719a289a3a28] = 168
 stub code      [0x0000719a289a3a28,0x0000719a289a3a58] = 48
 oops           [0x0000719a289a3a58,0x0000719a289a3a60] = 8
 mutable data [0x00007199d8024530,0x00007199d8024568] = 56
 relocation     [0x00007199d8024530,0x00007199d8024560] = 48
 metadata       [0x00007199d8024560,0x00007199d8024568] = 8
 immutable data [0x00007199d80244b0,0x00007199d8024520] = 112
 dependencies   [0x00007199d80244b0,0x00007199d80244b8] = 8
 scopes pcs     [0x00007199d80244b8,0x00007199d8024508] = 80
 scopes data    [0x00007199d8024508,0x00007199d8024520] = 24

Այն, ինչ հիմա ինձ ամենաշատն է հետաքրքրում, total in heap-ն է։ Հատկության անունը կարող է խաբուսիկ լինել, բայց այն իրականում ցույց է տալիս, թե որքան code cache հիշողություն է զբաղեցնում այս կոմպիլացված մեթոդը։ Այստեղ ընդհանուր չափը 472 բայթ է, մինչդեռ մեթոդի իրական իրականացումը զբաղեցնում է 168 բայթ։

Այնուհետև նույնը կարող ենք անել Tier 2-ի և Tier 3-ի համար։ Ելքը բաց կթողնեմ, բայց ահա չափերը յուրաքանչյուր մակարդակի համար։

Tier 1 Tier 2 Tier 3
ընդհանուր չափ 472 536 576
հիմնական կոդի չափ 168 232 272

Այս թվերը ցույց են տալիս, թե ինչու է Tier 3-ից Tier 4 չկոմպիլացվող մեթոդը ետ ընկնում Tier 2։ Սահմանափակ պրոֆիլավորման տվյալների շնորհիվ այն ավելի փոքր է։

C2 կոմպիլյատոր

Սա կոմպիլյացիայի վերջին փուլն է, որտեղ հայտնվում են hot մեթոդները։ Այն հաճախ կոչվում է server կոմպիլյատոր և կիրառում է մի շարք ագրեսիվ օպտիմիզացիաներ, ինչպիսիք են branch prediction-ը, վեկտորիզացիան և ցիկլերի բացումը (loop unrolling)։

Այս օպտիմիզացիաներից շատերը հիմնված են կանխատեսումների վրա։ Այլ կերպ ասած, պրոֆիլավորման տվյալների միջոցով JVM-ը ենթադրում է, որ մեթոդը կաշխատի այնպես, ինչպես նախկինում։ Այս ենթադրությունը, սակայն, միշտ չէ, որ ճիշտ է լինում։ Երբ ճիշտ չէ, JVM-ը նկատում է անհամապատասխանությունը և այդ մեթոդի համար վերադառնում է մեկնաբանվող կոդին։ Այնուհետև մեթոդի պրոֆիլավորման տվյալները նորից են հավաքվում, և կոմպիլյացիայի ամբողջ ցիկլը կարող է սկսվել նորից։

Ինչպես նշվեց նախկինում, C2-ով կոմպիլացված մեթոդները խիստ օպտիմիզացված են և պրոֆիլավորման տվյալներ չեն կրում։ Մանրամասները տեսնելու համար գործարկեք այս հրամանը.

java -XX:+UnlockDiagnosticVMOptions -XX:+PrintAssembly -XX:-BackgroundCompilation -jar target/app.jar 15000

Այս հրամանը ավելացնում է տարբերակը.

  • -XX:-BackgroundCompilation, որը JIT կոմպիլյատորին ստիպում է մեթոդները կոմպիլացնել սինխրոն, ֆոնային ռեժիմի փոխարեն։ Ինձ այս տարբերակը պետք էր, քանի որ իմ ծրագիրը շատ արագ է ավարտվում, և առանց դրա կոմպիլյացիան կարող էր չավարտվել ծրագրի դուրս գալուց առաջ։

Դրանով կարող ենք ընդլայնել ավելի վաղ բերված աղյուսակը՝ ավելացնելով resolveNumber մեթոդի C2-ով կոմպիլացված տարբերակը։

Tier 1 Tier 2 Tier 3 Tier 4
ընդհանուր չափ 472 536 576 392
հիմնական կոդի չափ 168 232 272 112

C2 կոմպիլյացիան տալիս է ամենափոքր կոմպիլացված մեթոդը, ինչը ցույց է տալիս, որ C2-ը իրական օգուտներ է բերում նույնիսկ պարզ մեթոդների համար։ Սակայն նրա հիմնական թերությունն այն է, որ արժե ժամանակ և ռեսուրսներ։

Նկատի ունեցեք, որ -XX:CICompilerCount տարբերակը թույլ է տալիս վերահսկել, թե JIT կոմպիլյատորը քանի թել է օգտագործում։ Կա նաև -XX:CICompilerCountPerCPU անունով տարբերակ։ Երբ այն միացված է, JVM-ը ավտոմատ կերպով որոշում է JIT կոմպիլյատորի թելերի քանակը՝ ելնելով հասանելի CPU միջուկների քանակից։ Օրինակ՝ 4 միջուկանի CPU-ի վրա կարող եք սպասել C2 կոմպիլյատորի համար 2 թել, իսկ C1 կոմպիլյատորի համար՝ 1 թել։

Գոյություն ունեն նաև մի քանի տարբերակներ կոմպիլյացիայի յուրաքանչյուր մակարդակի շեմերը վերահսկելու համար։ Դրանք մանրամասն չեմ նկարագրի, բայց կարող եք թվարկել այս հրամանով.

java -XX:+PrintFlagsFinal | grep Tier

Code cache

Կա ևս մեկ մաս, որը կցանկանայի ներկայացնել՝ code cache-ը։ Կոդը կոմպիլացվելուց հետո այն պետք է պահվի հեշտ հասանելի տեղում։ Լռելյայն code cache-ը բաժանված է երեք հատվածի.

  • JVM internal (non-method) code – այս հատվածը պահում է մեկնաբանվող կոդը, որը cache-ում մնում է մշտապես։ Դրա չափը կարելի է սահմանել -XX:NonProfiledCodeHeapSize տարբերակով։
  • Profiled-code – այս հատվածը պարունակում է C1 կոմպիլյատորի արտադրած թեթևակի օպտիմիզացված կոդը և կարճատև է։ Դրա չափը կարելի է սահմանել -XX:ProfiledCodeHeapSize տարբերակով։
  • Non-profiled code – այս հատվածը պահում է C2 կոմպիլյատորի արտադրած լիովին օպտիմիզացված կոդը։ Դրա չափը կարելի է վերահսկել -XX:NonNMethodCodeHeapSize տարբերակով։

Կան նաև code cache-ի հետ կապված մի քանի այլ JVM տարբերակներ, որոնք կարող են օգտակար լինել.

  • -XX:InitialCodeCacheSize
  • -XX:ReservedCodeCacheSize
  • -XX:CodeCacheExpansionSize
  • -XX:+PrintCodeCache

Եզրակացություն

Այս բլոգ գրառման մեջ իմ նպատակն էր բացատրել բայթկոդը բնիկ կոդի վերածելու հիմքում ընկած հիմնական հասկացությունները։ Գործընթացը շատ դինամիկ է և խիստ կարգավորելի։ Այն իրոք պահանջում է զգալի ժամանակ և ռեսուրսներ, բայց ժամանակի ընթացքում կարող է մեծապես բարելավել մեր ծրագրերի արտադրողականությունը։

Այս հոդվածի բոլոր օրինակները գործարկվել են Ubuntu 24.04.3 LTS, x86_64-ի վրա՝ OpenJDK Runtime Environment Temurin-25+36 (build 25+36-LTS)-ով։ Հուսով եմ՝ այս հոդվածը ձեզ ավելի հստակ պատկերացում է տալիս, թե ինչպես է JVM-ը արտադրում բնիկ կոդ։