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

Ներածություն JVM մեթոդների պրոֆիլավորմանը

JIT կոմպիլյատորով կոմպիլյացված մեթոդի չափը կախված է նրանից, թե որքան պրոֆիլավորման տվյալ է այն պարունակում։ Ի՞նչ է սա իրականում նշանակում։ Այս հոդվածը պատասխանում է այդ հարցին և նկարագրում, թե ընդհանրապես ինչպես է աշխատում պրոֆիլավորման մեխանիզմը։

11 րոպե
JavaJVMJava Internals

JIT կոմպիլյատորով կոմպիլյացված մեթոդի չափը կախված է նրանից, թե որքան պրոֆիլավորման տվյալ է այն պարունակում։ Բայց ի՞նչ է սա իրականում նշանակում։ Այս հոդվածը պատասխանում է այդ հարցին և նաև նկարագրում է, թե ընդհանրապես ինչպես է աշխատում պրոֆիլավորման մեխանիզմը։

Փորձ

Միջավայր

Ես իմ հետազոտությունը կատարել եմ GCP-ի վիրտուալ մեքենայի վրա, որն աշխատում էր Debian GNU/Linux 12 (bookworm)-ով amd64 ճարտարապետությամբ։ Տեղադրված Java տարբերակը Temurin-25+36 (build 25+36-LTS) էր։ Metaspace-ում գտնվող JVM-ի ներքին օբյեկտների վիճակը ուսումնասիրելու համար օգտագործել եմ jhsdb ծրագիրը։

Ծրագրի գործարկումը

Փորձում օգտագործված ծրագիրը ըստ էության պարզ ցիկլ է, որը ներկայացված է ստորև՝

static void main(String[] args) throws InterruptedException {
    var nrOfIterations = Integer.parseInt(args[0]);
    var sleepInMillis = Integer.parseInt(args[1]);
    var argumentHolder = new ArgumentsHolder(nrOfIterations, sleepInMillis);
    var sum = 0;
    for (int i = 1; i <= argumentHolder.getNrOfIterations(); i++) {
        IO.println("This is: " + i + " iteration");
        Thread.sleep(resolveSleepInMillis(i, argumentHolder.getSleepInMillis()));
        sum += resolveNumber(i);
    }
    IO.println("My fantastic sum is: " + sum);
}

Thread.sleep() կանչը այնտեղ է, որպեսզի կարողանամ JVM-ը դադարեցնել որոշակի պահերին։

Ծրագիրը գործարկեցի այս հրամանով՝

java -XX:+PrintCompilation -jar target/app.jar 100000 100

Գործարկման հրամանին ավելացրեցի PrintCompilation դրոշը, քանի որ այն ցույց է տալիս, թե երբ են որոշակի մեթոդները կոմպիլյացվում JIT կոմպիլյատորով կամ վերադարձվում interpreter ռեժիմի (decompile)։

Աշխատող JVM-ին command-line debugger միացնելու համար նախ պետք էր պարզել դրա պրոցեսի ID-ն։ Pid-ը ձեռքի տակ ունենալով՝ կարող էի գործարկել՝

jhsdb clhsdb --pid <pid>

Debugger-ը միացնելուց հետո կարող էի դիտել մեթոդների մանրամասները, բայց նախ պետք էին մի քանի նախնական քայլեր։

  • Դասի հիշողության ցուցիչի գտնումը լրիվ որակավորված դասի անունից՝
class org.zygiert.Main
  • Այս հրամանը վերադարձրեց Metaspace-ում գտնվող իրական InstanceKlass օբյեկտի ցուցիչը
  • Այն օգտագործելով՝ կարող էի գործարկել՝
inspect <memory_address>
  • Այս հրամանը վերադարձրեց դասի մասին մանրամասն տեղեկատվություն։ Ամենակարևոր մասը մեթոդների զանգվածի ցուցիչն էր՝
Array<Method*>* InstanceKlass::_methods: Array<Method*> @ 0x00007f307c400400
  • Զանգվածի իրական պարունակությունը դիտելու համար գործարկեցի ստորև բերված հրամանը (5-ը նշանակում է, որ ցուցադրվում է հինգ հիշողության բառ)՝
mem 0x00007f307c400400/5
  • Արդյունքը հետևյալն էր (առաջին տողը տալիս է զանգվածի չափը, իսկ հաջորդ չորսը այս դասի մեթոդների հաջորդական ցուցիչներն են)՝
0x00007f307c400400: 0x0000000000000004
0x00007f307c400408: 0x00007f307c400478
0x00007f307c400410: 0x00007f307c4005c0
0x00007f307c400418: 0x00007f307c400768
0x00007f307c400420: 0x00007f307c400698

Սա ինձ տվեց հետաքրքիր պատկերացումներ այն մասին, թե ինչպես է մեթոդի մետատվյալը զարգանում հավելվածի աշխատանքի ընթացքում։ Օգտագործեցի վերը նշված inspect հրամանը։ Նույն քայլերը կարելի է կրկնել կոդային բազայի ցանկացած դասի համար։ Իմ դեպքում կար ևս մեկ դաս, որը հատկապես հետաքրքրում էր ինձ։

Մակարդակ 0

Իմ ծրագիրը առաջին անգամ դադարեց 235-րդ իտերացիայի ժամանակ։ Իմանալով յուրաքանչյուր մեթոդի հիշողության հասցեն՝ կարողացա հասնել մեթոդի մետատվյալին։ main մեթոդի համար այն ունեցավ այսպիսի տեսք՝

Type is Method (size of 88)
ConstMethod* Method::_constMethod: ConstMethod @ 0x00007f307c4004d0
MethodData* Method::_method_data: MethodData @ null
MethodCounters* Method::_method_counters: MethodCounters @ 0x00007f307c4009a0
AccessFlags Method::_access_flags: 8
int Method::_vtable_index: -2
u2 Method::_intrinsic_id: 0
nmethod* Method::_code: nmethod @ null
address Method::_i2i_entry: address @ 0x00007f307c4005f8
address Method::_from_compiled_entry: address @ 0x00007f307c400600
address Method::_from_interpreted_entry: address @ 0x00007f307c400610

Պրոֆիլավորման տեսանկյունից կարելի է նկատել մի քանի կարևոր բան՝

  • Այս փուլում MethodData-ի հղում չկա։
  • MethodCounters-ի հղում գոյություն ունի, ինչը ցույց է տալիս, որ պրոֆիլավորումն արդեն ընթանում է։
  • Կոմպիլյացված մեքենայական կոդի հղում չկա. nmethod ցուցիչը null է, ինչը նշանակում է, որ մեթոդը առայժմ աշխատում է interpreter ռեժիմում։

Հիմա նայենք MethodCounters օբյեկտներին։ Ստորև բերված է երեք մեթոդի արդյունքը՝

  • main՝
Type is MethodCounters (size of 64)
int MethodCounters::_invoke_mask: 254
int MethodCounters::_backedge_mask: 2046
u2 MethodCounters::_interpreter_throwout_count: 0
u2 MethodCounters::_number_of_breakpoints: 0
InvocationCounter MethodCounters::_invocation_counter: 2
InvocationCounter MethodCounters::_backedge_counter: 468
  • resolveNumber՝
Type is MethodCounters (size of 64)
int MethodCounters::_invoke_mask: 254
int MethodCounters::_backedge_mask: 2046
u2 MethodCounters::_interpreter_throwout_count: 0
u2 MethodCounters::_number_of_breakpoints: 0
InvocationCounter MethodCounters::_invocation_counter: 468
InvocationCounter MethodCounters::_backedge_counter: 0
  • resolveSleepInMillis՝
Type is MethodCounters (size of 64)
int MethodCounters::_invoke_mask: 254
int MethodCounters::_backedge_mask: 2046
u2 MethodCounters::_interpreter_throwout_count: 0
u2 MethodCounters::_number_of_breakpoints: 0
InvocationCounter MethodCounters::_invocation_counter: 470
InvocationCounter MethodCounters::_backedge_counter: 0

Սա նաև մի հետաքրքիր բան է ասում պրոֆիլավորման աշխատանքի մասին։ main մեթոդի համար invocation counter-ը 2 է, իսկ backedge counter-ը՝ 468։ Սա ցույց է տալիս, որ interpreter ռեժիմում JVM-ը հավաքում է տեղեկատվություն՝

  • Քանի անգամ է մեթոդը կանչվել. սա invocation counter-ն է
  • Քանի անգամ է այդ մեթոդի ներսի ցիկլը իտերացիա կատարել. սա backedge counter-ն է

Ուրեմն ինչո՞ւ 235-րդ իտերացիայի ժամանակ backedge counter-ը 468 է, այլ ոչ թե 235։ Որովհետև JVM-ը counter-ները մեծացնում է 2-ով, ոչ թե 1-ով։ Արժեքը 468 է, այլ ոչ թե 470, որովհետև մենք իտերացիայի քայլի կեսին ենք, ուստի backedge counter-ը դեռ չի հասցրել աճել մինչև 470։

Վերադառնալով սկզբնական հարցին՝ JVM-ը counter-ները մեծացնում է 2-ով արագագործության համար։ Counter-ի արժեքը պահվում է որպես ամբողջ թիվ, որը 32 բիթ երկարություն ունի։ Առաջին բիթը կոչվում է carry բիթ։ 2-ով ավելացումը carry բիթը չի շոշափում։

Սա կարևոր է, քանի որ որոշելու համար, թե արդյոք մեթոդը պետք է ստուգվի ավելի բարձր Tier-ում կոմպիլյացիայի համար, JVM-ը counter-ի արժեքի և mask-ի վրա կատարում է bitwise AND, ինչը ավելի էժան է, քան թվաբանական համեմատությունը։ carry բիթ ունենալը դա հնարավոր է դարձնում։

Ավելին, JVM-ը չի ստուգում յուրաքանչյուր ավելացումից հետո, թե արդյոք մեթոդը պետք է կոմպիլյացվի ավելի բարձր Tier-ում։ Այդ ստուգումների հաճախականությունը փոխարենը կառավարվում է invoke_mask և backedge_mask արժեքներով։ Interpreter ռեժիմում դրանք ածանցվում են Tier0InvokeNotifyFreqLog (լռելյայն արժեք՝ 7) և Tier0BackedgeNotifyFreqLog (լռելյայն արժեք՝ 10) արժեքներից։ Իրական հաշվարկը կատարող կոդը կարելի է գտնել methodCounters.cpp-ում։

Մեր օրինակում, երբ invoke_mask-ը 254 է, ավելի բարձր Tier-ում կոմպիլյացիայի ստուգումները տեղի են ունենում մեթոդի յուրաքանչյուր 128 կանչից հետո։ Backedge-ների համար ստուգումները տեղի են ունենում յուրաքանչյուր 1024 backedge-ից հետո։

Մակարդակ 1

Իմ կոդում ես միտումնավոր ավելացրի ArgumentsHolder դասը երկու getter-ով, որպեսզի ցույց տամ, որ Tier 1-ը պրոֆիլավորման տվյալներ չունի։ Երկու getter-ների համար counter-ները ունեն այսպիսի տեսք՝

InvocationCounter MethodCounters::_invocation_counter: 256
InvocationCounter MethodCounters::_backedge_counter: 0

Counter-ները դադարեցին աճել մեթոդի 128 կանչից հետո։ Մինչ այդ C1 կոմպիլյատորը արդեն կոմպիլյացրել է getter-ները։ Դա կարող ենք հաստատել՝ նայելով մեթոդի մետատվյալին։ getNrOfIterations-ի համար այն ունի այսպիսի տեսք՝

Type is Method (size of 88)
ConstMethod* Method::_constMethod: ConstMethod @ 0x00007f307c400c60
MethodData* Method::_method_data: MethodData @ null
MethodCounters* Method::_method_counters: MethodCounters @ 0x00007f307c400ec8
AccessFlags Method::_access_flags: 2
int Method::_vtable_index: -2
u2 Method::_intrinsic_id: 0
nmethod* Method::_code: nmethod @ 0x00007f30a3ecc788
address Method::_i2i_entry: address @ 0x00007f307c400ce8
address Method::_from_compiled_entry: address @ 0x00007f307c400cf0
address Method::_from_interpreted_entry: address @ 0x00007f307c400d00

Սա թույլ է տալիս նկատել հետևյալը՝

  • Ճիշտ ինչպես interpreter ռեժիմում, MethodData-ի հղում չկա։
  • nmethod-ը null չէ, ինչը նշանակում է, որ այս մեթոդի մեքենայական կոդը պահվում է code cache-ում։ Սակայն այդ մեքենայական կոդը counter-ները մեծացնելու համար լրացուցիչ ինստրումենտացիա չի պարունակում։

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

disassemble <memory_address>

Մակարդակ 3

Հաջորդ դադարը տեղի ունեցավ 314-րդ իտերացիայի ժամանակ։ Մինչ այդ C1 կոմպիլյատորը արդեն կոմպիլյացրել է նաև resolveNumber մեթոդը։ Նայելով մեթոդի մետատվյալին՝ տեսնում ենք այսպիսի մանրամասներ՝

Type is Method (size of 88)
ConstMethod* Method::_constMethod: ConstMethod @ 0x00007f307c400638
MethodData* Method::_method_data: MethodData @ 0x00007f307c401928
MethodCounters* Method::_method_counters: MethodCounters @ 0x00007f307c400f88
AccessFlags Method::_access_flags: 10
int Method::_vtable_index: -2
u2 Method::_intrinsic_id: 0
nmethod* Method::_code: nmethod @ 0x00007f309c427588
address Method::_i2i_entry: address @ 0x00007f307c4006d0
address Method::_from_compiled_entry: address @ 0x00007f307c4006d8
address Method::_from_interpreted_entry: address @ 0x00007f307c4006e8

Հիմնական նկատելի բաներն են՝

  • Հայտնվել է MethodData օբյեկտ, որը կհավաքի ավելի մանրամասն պրոֆիլավորման տեղեկատվություն
  • MethodCounters օբյեկտը դեռ կա, բայց այժմ այն «սառեցված» է
  • Կա կոմպիլյացված մեքենայական կոդ, ինչպես ցույց է տալիս null չլինող nmethod-ը

Ահա resolveNumber մեթոդի սկզբնական կոդը՝

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

Այս մեթոդի համար գեներացված մեքենայական կոդը պարունակում է լրացուցիչ կոդ, որը բեռնում է counter-ները, մեծացնում դրանք և պահպանում հետ։ «Counter-ներ» այստեղ նշանակում է ոչ միայն invocation counter-ը, այլև MethodData-ում պահվող taken և not taken branch counter-ները։ Հենց դա է նշանակում «լրիվ պրոֆիլավորման տվյալներ» այս մեթոդի համար։

Այսուհետ MethodCounters-ն այլևս չի փոխվի՝

InvocationCounter MethodCounters::_invocation_counter: 512
InvocationCounter MethodCounters::_backedge_counter: 0

invocation_counter-ը կանգ առավ 256 իտերացիայից հետո։ Սակայն MethodData-ի ներսում կա երկրորդ invocation_counter։

Նայելով մեթոդի մեքենայական կոդին՝ կարող ենք գտնել հիշողության այն հասցեն, որն այն օգտագործում է։ Invocation counter-ին վերաբերող մեքենայական կոդի հատվածն ունի այսպիսի տեսք՝

0x00007f309c42769b:    movabs $0x7f307c401928,%rax
0x00007f309c4276a5:    mov    0x90(%rax),%edi
0x00007f309c4276ab:    add    $0x2,%edi
0x00007f309c4276ae:    mov    %edi,0x90(%rax)

Երկրորդ տողը բեռնում է counter-ը 0x90 շեղումից (տասնվեցական, այսինքն՝ տասնորդական 144) MethodData ցուցիչի նկատմամբ։ Քանի որ գիտենք MethodData-ի հասցեն, կարող ենք հաշվել invocation counter-ի հասցեն և ստուգել այն այս jhsdb հրամանով՝

printas InvocationCounter <memory_address>

Արդյունքը հետևյալն է՝

pointer to unsigned InvocationCounter @ 0x00007f307c4019b8 (size = 4)
unsigned int InvocationCounter::_counter: 114

Այս counter-ը նույնպես ամեն կանչի ժամանակ աճում է 2-ով։ Դա նշանակում է, որ այն ստեղծվելուց հետո մեծացվել է 57 անգամ։ Counter-ը ստեղծվել է, երբ այս մեթոդը անցավ ավելի բարձր Tier, ինչը տեղի ունեցավ 256 կանչից հետո։ Թեև իմ հավելվածի լոգը հայտնում էր ցիկլի 314 իտերացիայի մասին, resolveNumber մեթոդը դեռ չէր կանչվել։ Ահա թե ինչու counter-ի արժեքը 114 է (314 - 256 = 58. քանի որ այդ կանչը դեռ տեղի չի ունեցել, ստանում ենք 57)։

Տեսնում ենք, որ այս counter-ը օգտագործվել է ստեղծվելու պահից ի վեր, և 1739-րդ իտերացիայի ժամանակ դրա արժեքն է՝

pointer to unsigned InvocationCounter @ 0x00007f307c4019b8 (size = 4)
unsigned int InvocationCounter::_counter: 2964

Մակարդակ 4

5120 կանչից հետո C2 կոմպիլյատորը կոմպիլյացրել է resolveNumber մեթոդը։ Ես ծրագիրը նորից դադարեցրի ցիկլի 5513-րդ իտերացիայի ժամանակ։ Մինչ այդ invocation counter-ը սառել է այն արժեքի վրա, որը առաջացրել է C2 կոմպիլյացիան, քանի որ C2-ով կոմպիլյացված կոդը պրոֆիլավորման տվյալներ չի հավաքում։ Սա invocation counter-ի արժեքն է՝

pointer to unsigned InvocationCounter @ 0x00007f307c4019b8 (size = 4)
unsigned int InvocationCounter::_counter: 10240

Deoptimization

10 000 կանչից հետո resolveNumber մեթոդը deoptimize արվեց։ Այսպես է սահմանված մեթոդը՝

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

Սկզբում JIT կոմպիլյատորը կիրառեց սպեկուլյատիվ օպտիմիզացիա՝ պարզելով, որ i-ի 10 000-ից փոքր արժեքների համար մեթոդը միշտ վերադարձնում է i։ Սակայն երբ կանչերը անցան 10 000-ը, կոդը սկսեց անցնել else ճյուղով, ինչը առաջացրեց deoptimization։

Եկեք ավելի մոտիկից նայենք, թե գործնականում ինչ է սա նշանակում։ Ահա մեթոդի մետատվյալը՝

Type is Method (size of 88)
ConstMethod* Method::_constMethod: ConstMethod @ 0x00007f307c400638
MethodData* Method::_method_data: MethodData @ 0x00007f307c401928
MethodCounters* Method::_method_counters: MethodCounters @ 0x00007f307c400f88
AccessFlags Method::_access_flags: 10
int Method::_vtable_index: -2
u2 Method::_intrinsic_id: 0
nmethod* Method::_code: nmethod @ null
address Method::_i2i_entry: address @ 0x00007f307c4006d0
address Method::_from_compiled_entry: address @ 0x00007f307c4006d8
address Method::_from_interpreted_entry: address @ 0x00007f307c4006e8
  • MethodData-ի հղումը null չէ, ինչը ցույց է տալիս, որ այն deoptimization-ից հետո չի հեռացվել
  • nmethod-ի հղումը վերացել է, քանի որ մեթոդը deoptimize է արվել

Invocation counter-ը նորից սկսել է աճել՝

pointer to unsigned InvocationCounter @ 0x00007f307c4019b8 (size = 4)
unsigned int InvocationCounter::_counter: 10290

Բացի այդ, MethodData-ն թարմացվել է՝

uint MethodData::_compiler_counters._nof_decompiles: 1

Բացակայող օղակը

Նախորդ բաժիններում անցանք կոմպիլյացիայի բոլոր Tier-ներով, բացի մեկից՝ Tier 2-ից։ Այս Tier-ը, կարծես, գալիս է «սահմանափակ պրոֆիլավորման տվյալներով»։ Մեթոդը Tier 2-ում կոմպիլյացնելը հեշտ չէ, ուստի JVM-ին դա անել տվեցի՝ գործարկելով այս հրամանը՝

java -XX:+PrintCompilation -XX:TieredStopAtLevel=2 -jar target/app.jar 1000 100

«Սահմանափակ պրոֆիլավորում» նշանակում է, որ այս tier-ում JVM-ը մանրամասն պրոֆիլավորման տեղեկատվություն չի հավաքում, ինչպիսին են, օրինակ, taken branch-ները։ Այն միայն մեծացնում է invocation և backedge counter-ները։ MethodData օբյեկտ իսկապես գոյություն ունի, բայց այն հավաքած տվյալները նվազագույն են։

Type is Method (size of 88)
ConstMethod* Method::_constMethod: ConstMethod @ 0x00007fa840400638
MethodData* Method::_method_data: MethodData @ 0x00007fa840401928
MethodCounters* Method::_method_counters: MethodCounters @ 0x00007fa840400f88
AccessFlags Method::_access_flags: 10
int Method::_vtable_index: -2
u2 Method::_intrinsic_id: 0
nmethod* Method::_code: nmethod @ 0x00007fa860546188
address Method::_i2i_entry: address @ 0x00007fa8404006d0
address Method::_from_compiled_entry: address @ 0x00007fa8404006d8
address Method::_from_interpreted_entry: address @ 0x00007fa8404006e8

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

JVM-ը պրոֆիլավորման տեղեկատվությունը պահելու համար հենվում է երկու հիմնական տվյալների կառուցվածքի վրա՝

  • MethodCounters, որն օգտագործվում է, երբ ծրագիրը սկսում է աշխատել
  • MethodData, կառուցվածք, որը ստեղծվում է, երբ JIT կոմպիլյատորը կոմպիլյացնում է մեթոդը։ Այն շարունակում է օգտագործվել նույնիսկ երբ մեթոդը deoptimize է արվում և վերադառնում interpreter ռեժիմ։ Դրան գումարվում է, որ MethodData-ն թույլ է տալիս JVM-ին հավաքել ավելի մանրամասն տեղեկատվություն, որը C2 կոմպիլյատորը հետագայում կարող է օգտագործել մեքենայական կոդն ավելի արդյունավետ օպտիմիզացնելու համար

Հուսով եմ՝ այս հոդվածը օգտակար պատկերացում է տալիս այն մասին, թե ընդհանրապես ինչպես է աշխատում մեթոդների պրոֆիլավորումը։