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

JVM-ի աշխատասերները՝ Stub-երն ու Intrinsic-ները

Այս հոդվածը նկարագրում է, թե ինչ են stub-երը և ինչու են դրանք այդքան կարևոր JVM-ի ներսում։

10 րոպե
JavaJVMJava InternalsIntrinsicsStubs

Մի քանի շաբաթ առաջ ես ուսումնասիրում էի hot path-ը այն նախագծում, որի վրա ներկայումս աշխատում եմ։ Կոդը մի քանի անգամ կանչում էր այս մեթոդը՝

System.arracopy(args...)

Դրա հիման վրա ես կասկածեցի, որ այս օրինաչափությունը կարող է օպտիմալ չլինել՝ ենթադրելով, որ պատճենումը պահանջում է թանկ կանչ native գրադարանին։ Իմ ենթադրությունը բխում էր մեթոդի սիգնատուրայից՝

public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);

Բայց երբ նայեցի C2-ի գեներացրած մեքենայական կոդին, նկատեցի Final Stub-ի մի քանի կանչ։

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

Միջավայր

Վերլուծության համար օգտագործել եմ JDK-ի այս տարբերակը՝ OpenJDK Runtime Environment Temurin-25.0.2+10 (build 25.0.2+10-LTS)։ Մեքենան Intel(R) Xeon(R) @ 2.20GHz - 4 vCPU (2 core), 16GB RAM էր, որն աշխատում էր Debian GNU/Linux 12 (bookworm)-ով։

Փորձարկման համար հենվել եմ OpenJDK repository-ի Adoptium հայելու վրա jdk-25.0.2+10 tag-ում։

Stub-եր

Stub-երը assembly կոդի հատվածներ են, որոնք գեներացվում և օպտիմիզացվում են կոնկրետ խնդիրների համար, ինչպիսիք են կրիպտոգրաֆիական ֆունկցիաները, մաթեմատիկական գործողությունները և զանգվածների պատճենումը։ Դրանք ստեղծվում են JVM-ի գործարկման ժամանակ։

init.cpp ֆայլը պարունակում է հետևյալ ֆունկցիաների կանչերը՝

// stub routines in initial blob are referenced by later generated code
initial_stubs_init();
...
continuation_stubs_init(); // depends on continuations_init
...
compiler_stubs_init(false /* in_compiler_thread */); // compiler's intrinsics stubs
final_stubs_init();    // final StubRoutines stubs

Սա ցույց է տալիս, որ stub ռուտինների գեներացումը բաժանված է մի քանի առանձին քայլերի՝

  • Initial stub-եր
  • Continuation stub-եր
  • Compiler stub-եր
  • Final stub-եր

Քանի որ որոշ stub-եր հենվում են մյուսների վրա, այս հերթականությունը էական է դրանց ճիշտ գեներացման համար։

Stub-երի գեներացումը որքան ժամանակ է տևում ստուգելու համար կարող ենք գործարկել հետևյալ հրամանը՝

scala-cli . --main-class playground.Main --java-opt -Xlog:startuptime --power

Այն տպում է հետևյալը՝

[0.005s][info][startuptime] StubRoutines generation initial stubs, 0.0005537 secs
...
[0.019s][info][startuptime] StubRoutines generation continuation stubs, 0.0000309 secs
...
[0.026s][info][startuptime] StubRoutines generation final stubs, 0.0003121 secs
...
[0.041s][info][startuptime] StubRoutines generation compiler stubs, 0.0033504 secs

Պարզվում է՝ գեներացումը չափազանց արագ է։ Ամենաերկար փուլը՝ compiler stub-երի գեներացումը, տևեց մոտ 3 ms, իսկ մնացած փուլերն ավարտվեցին միկրովայրկյանների ընթացքում։

Գեներացված assembly կոդը կարելի է ուսումնասիրել նաև -XX:+PrintStubCode ընտրանքը միացնելով։

Ինչպես բացատրվում է stubRoutines.hpp-ի փաստաթղթավորման մեջ, թեև յուրաքանչյուր քայլ (initial, final և այլն) կարող է արտադրել բազմաթիվ stub-եր, դրանք բոլորը հայտնվում են մեկ BufferBlob-ում, որը պարզապես պահում է բազմաթիվ մուտքի կետեր։ Սա տարբերվում է SharedRuntime-ի գեներացրած stub-երից (որոնք հայտնի են նաև որպես blob-եր), որոնցից յուրաքանչյուրը փաթեթավորվում է իր սեփական BufferBlob-ում։

BufferBlob-ը կոնտեյներ է, որը պարունակում է Code Cache-ում պահվող մեքենայական կոդ։

Stub-երն ունեն ևս մեկ հետաքրքիր հատկություն, որը դրանք դարձնում է էլ ավելի արդյունավետ. դրանցից որոշները կարող են կոմպիլյացվել intrinsics օգտագործելով։

Intrinsic-ներ

Intrinsic-ները կարող եք պատկերացնել որպես մասնագիտացված assembly կոդ, որը գրված է հատուկ կոնկրետ CPU ճարտարապետության համար։ Intrinsic ֆունկցիան օգտագործում է Instruction Set Architecture (ISA)-ի որոշակի հրահանգներ, որոնք մի պրոցեսորից մյուսը տարբերվում են։

Թեև հասանելի intrinsic-ների ամբողջական ցանկը սահմանված է vmIntrinsics.hpp-ում, դրանցից ոչ բոլորն են իրականացված յուրաքանչյուր CPU ճարտարապետության համար։ Ահա թե ինչու StubCodeGenerator-ը պետք է իրականացվի առանձին յուրաքանչյուր թիրախային ճարտարապետության համար։

Եկեք խաղանք դրանց հետ պարզ Java օրինակով՝

private static long power() {
    var result = 0L;
    for (int i = 0; i < 1_000_000; i++) {
        result += (long) Math.pow(i, 2.0);
    }
    return result;
}

Սկզբում կարող ենք թվարկել ծրագրի օգտագործած intrinsic-ները՝ հրամանին ավելացնելով PrintIntrinsics ընտրանքը՝

scala-cli . --main-class playground.Main --java-opt -XX:+UnlockDiagnosticVMOptions --java-opt -XX:+PrintIntrinsics --power

Այստեղ արդյունքը կպարունակի այսպիսի լոգի տող՝

@ 16   java.lang.Math::pow (6 bytes)   (intrinsic)

Սա մեզ ասում է, որ JIT կոմպիլյատորը intrinsify է արել pow ֆունկցիան։ Սակայն կան նաև intrinsic-ները անջատելու եղանակներ, որոնց անդրադառնում եմ հաջորդիվ։

Անջատել InlineNatives-ը

Մեր տրամադրության տակ առաջին տարբերակը InlineNatives-ի անջատումն է։ Երբ այս կարգավորումն անջատված է և ծրագիրը գործարկվում է այսպես՝

scala-cli . --main-class playground.Main --java-opt -XX:+UnlockDiagnosticVMOptions --java-opt -XX:+PrintIntrinsics --java-opt -XX:-InlineNatives --power

pow ֆունկցիան դադարում է intrinsify լինել։ Փոխարենը լոգերը ցույց են տալիս, որ որոշ մեթոդներ inline են եղել, բայց ոչ մեկը intrinsify չի եղել՝

@ 2   java.lang.FdLibm$Pow::compute (1533 bytes)   failed to inline: hot method too big
@ 9   java.lang.Double::isNaN (12 bytes)   inline (hot)
@ 16   java.lang.Double::isNaN (12 bytes)   inline (hot)
@ 27   java.lang.Math::abs (12 bytes)   inline (hot)
  @ 1   java.lang.Double::doubleToRawLongBits (0 bytes)   failed to inline: native method
  @ 8   java.lang.Double::longBitsToDouble (0 bytes)   failed to inline: native method
@ 33   java.lang.Math::abs (12 bytes)   inline (hot)
  @ 1   java.lang.Double::doubleToRawLongBits (0 bytes)   failed to inline: native method
  @ 8   java.lang.Double::longBitsToDouble (0 bytes)   failed to inline: native method
@ 16   java.lang.Math::pow (6 bytes)   inline (hot)
  @ 2   java.lang.StrictMath::pow (6 bytes)   inline (hot)
    @ 2   java.lang.FdLibm$Pow::compute (1533 bytes)   failed to inline: hot method too big

Եկեք նորից նայենք գեներացված stub-երին։ InlineNatives-ն անջատված լինելու դեպքում JVM-ը բաց է թողնում stub-երի ստեղծումը շատ ֆունկցիաների համար, այդ թվում՝ pow, sin և doubleToRawLongBits։ Ազդեցության ենթարկված ֆունկցիաների ամբողջական ցանկը կարելի է ստանալ՝ ուսումնասիրելով vmIntrinsics::disabled_by_jvm_flags մեթոդը։

Կարևոր է, որ այս ընտրանքը միացված լինելու դեպքում stub-եր ընդհանրապես չեն արտադրվում, ուստի դրանք Code Cache-ում հիշողություն չեն զբաղեցնում։

ControlIntrinsic

Մինչդեռ նախորդ դրոշը աշխատում է «գլոբալ»՝ մեկ քայլով անջատելով շատ stub-եր, ControlIntrinsic ընտրանքը մեզ տալիս է շատ ավելի նուրբ վերահսկողություն (գոյություն ունի նաև DisableIntrinsic ընտրանք, բայց vmIntrinsics.hpp-ի փաստաթղթավորումն ասում է, որ այն պատրաստվում է հնացվել (deprecated))։

Intrinsic-ները միայն pow ֆունկցիայի համար անջատելու համար պետք է տրամադրենք այդ ֆունկցիայի intrinsic ID-ն։ Այն կարող ենք գտնել vmIntrinsics.hpp ֆայլում, որը յուրաքանչյուր intrinsic-ի համար ներառում է այսպիսի կոդ՝

do_intrinsic(_dpow, java_lang_Math, pow_name, double2_double_signature, F_S)

Մեզ անհրաժեշտ ID-ն առաջին արգումենտն է՝ _ dpow։ Իմանալով այն՝ կարող ենք գործարկել ծրագիրը այսպես՝

scala-cli . --main-class playground.Main --java-opt -XX:+UnlockDiagnosticVMOptions --java-opt -XX:+PrintIntrinsics --java-opt -XX:ControlIntrinsic=-_dpow --power

Այս անգամ արդյունքը տարբերվում է նախորդից՝

@ 2   java.lang.FdLibm$Pow::compute (1533 bytes)   failed to inline: hot method too big
@ 9   java.lang.Double::isNaN (12 bytes)   inline (hot)
@ 16   java.lang.Double::isNaN (12 bytes)   inline (hot)
@ 27   java.lang.Math::abs (12 bytes)   (intrinsic)
@ 33   java.lang.Math::abs (12 bytes)   (intrinsic)
@ 16   java.lang.Math::pow (6 bytes)   inline (hot)
  @ 2   java.lang.StrictMath::pow (6 bytes)   inline (hot)
    @ 2   java.lang.FdLibm$Pow::compute (1533 bytes)   failed to inline: hot method too big

Տեսնում ենք, որ մի քանի մեթոդներ inline են եղել, բայց abs-ը մնացել է intrinsified։ Այլ կերպ ասած՝ այս մոտեցումը թույլ է տալիս անջատել մեկ intrinsic՝ մնացածը թողնելով միացված։ Գեներացված stub-երը դա հաստատում են. բացակայում է միայն pow stub-ը։

Օգտագործել կոնկրետ ընտրանքներ

Կոնկրետ intrinsic-ներ անջատելու ևս մեկ եղանակ է առանձին ֆունկցիայի կամ ֆունկցիաների խմբի համար նախատեսված դրոշը։ Բոլոր հասանելի ընտրանքները թվարկելու համար կարող ենք գործարկել այս հրամանը՝

java -XX:+UnlockDiagnosticVMOptions -XX:+UnlockExperimentalVMOptions -XX:+PrintFlagsFinal -version | grep -Ei 'use.*intrinsic'

Արդյունքների մեջ մեկ ընտրանք առանձնանում է որպես հատկապես համապատասխան՝ UseLibmIntrinsic։

Եկեք նորից գործարկենք ծրագիրը՝ այս անգամ UseLibmIntrinsic-ն անջատված՝

scala-cli . --main-class playground.Main --java-opt -XX:+UnlockDiagnosticVMOptions --java-opt -XX:+PrintIntrinsics --java-opt -XX:-UseLibmIntrinsic --power

Արդյունքը անակնկալ էր՝

@ 16   java.lang.Math::pow (6 bytes)   (intrinsic)

Այն համընկնում է այն արդյունքի հետ, որ ստանում ենք բոլոր intrinsic-ները միացված ժամանակ։ Սակայն գեներացված stub-երին նայելը ցույց է տալիս, որ pow ֆունկցիայի, ինչպես նաև այլ մաթեմատիկական ֆունկցիաների, օրինակ՝ sin կամ log, stub-երը չեն գեներացվել։

Ոչ առաջին անգամ JVM-ը ինձ ցույց տվեց, որ հենց այն պահին, երբ կարծում եմ՝ պարզել եմ դրա վարքագիծը, դեռ շատ բան է մնում սովորելու։ Չեմ փորձի վերջնական բացատրություն տալ, թե ինչու է PrintIntrinsics ընտրանքն այդպես վարվում։ Փոխարենը կկիսվեմ իմ գտածոների հիման վրա արված մի քանի հիմնավորված ենթադրություններով։

Պարզելու համար, թե իրականում ինչ է կատարվում ներսում, գրեցի մի քանի benchmark։

Benchmark-եր

Իմ գրած benchmark-ները համեմատում են վերը քննարկված բոլոր մոտեցումները՝

@Benchmark
public void power_Intrinsics_On(Blackhole bh) {
    bh.consume(Math.pow(2.0, 10.0));
}

@Benchmark
@Fork(value = 3, jvmArgsAppend = {"-XX:+UnlockDiagnosticVMOptions", "-XX:-InlineNatives"})
public void power_Intrinsics_Off_Disabled_By_Inline_Natives(Blackhole bh) {
    bh.consume(Math.pow(2.0, 10.0));
}

@Benchmark
@Fork(value = 3, jvmArgsAppend = {"-XX:+UnlockDiagnosticVMOptions", "-XX:ControlIntrinsic=-_dpow"})
public void power_Intrinsics_Off_Disabled_By_Control_Intrinsic(Blackhole bh) {
    bh.consume(Math.pow(2.0, 10.0));
}

@Benchmark
@Fork(value = 3, jvmArgsAppend = {"-XX:+UnlockDiagnosticVMOptions", "-XX:-UseLibmIntrinsic"})
public void power_Intrinsics_Off_Disabled_By_Libm_Intrinsics(Blackhole bh) {
    bh.consume(Math.pow(2.0, 10.0));
}

Ահա արդյունքները՝

Benchmark                                                                    Mode  Cnt    Score   Error  Units
IntrinsicsPowerBenchmark.power_Intrinsics_Off_Disabled_By_Control_Intrinsic  avgt   15   91.580 ? 0.251  ns/op
IntrinsicsPowerBenchmark.power_Intrinsics_Off_Disabled_By_Inline_Natives     avgt   15  398.977 ? 1.606  ns/op
IntrinsicsPowerBenchmark.power_Intrinsics_Off_Disabled_By_Libm_Intrinsics    avgt   15   92.155 ? 0.377  ns/op
IntrinsicsPowerBenchmark.power_Intrinsics_On                                 avgt   15   22.240 ? 0.089  ns/op

Թվերը պարզորեն ցույց են տալիս, որ intrinsified pow ֆունկցիան զգալի տարբերությամբ գերազանցում է բոլոր այլընտրանքներին։ InlineNatives ընտրանքն անջատված տարբերակը, առանց որևէ կասկածի, ամենադանդաղն է։ Հետաքրքրաշարժ է, որ մնացած երկու տարբերակները գործում են գրեթե նույն կերպ։

Արդյունավետության վերլուծություն

Խորությամբ հասկանալու համար, թե ինչ է JVM-ը իրականում կատարում յուրաքանչյուր դեպքում, benchmark-ները գործարկեցի profiler-ը միացրած՝ օգտագործելով այս հրամանը՝

scala-cli . --jmh --power -- -f 1 -prof "perfasm:events=cpu-clock;intel=true"

Intrinsic-ները միացված

Այս դեպքը հեշտ է վերլուծել, քանի որ կատարման ժամանակի հիմնական մասը գնացել է pow ֆունկցիայի համար գեներացված stub-ի կանչին՝

88.14%          runtime stub  StubRoutines::dpow

Արդյունավետությունը լավ է, քանի որ ավելորդ ֆունկցիայի կանչեր չկան, և կոդը լիովին օպտիմիզացված է։

Intrinsic-ները անջատված InlineNatives-ով

Այս դեպքն էլ է բավականին հեշտ վերլուծել։ Հիմնական խցանումներն են՝

47.33%      Unknown, level 0  java.lang.Double::doubleToRawLongBits, version 1, compile id 312
32.45%      Unknown, level 0  java.lang.Double::longBitsToDouble, version 1, compile id 666
10.52%           c2, level 4  java.lang.FdLibm$Pow::compute, version 2, compile id 683

Քանի որ այս ընտրանքը անջատում է intrinsic-ների լայն շրջանակ, JVM-ը վերադառնում է pow-ի FdLibm իրականացմանը (C մաթեմատիկական գրադարանների Java պորտ, որը ստեղծվել է հաշվի առնելով շարժունակությունը, այլ ոչ թե արդյունավետությունը)։

Սակայն ժամանակի մեծ մասը ծախսվել է Double դասի երկու մեթոդի վրա՝

  • doubleToRawLongBits
  • longBitsToDouble

Սրանք native մեթոդներ են, որոնք սովորաբար intrinsify կլինեին, ուստի այդ հնարավորությունն անջատված լինելու դեպքում JVM-ը ստիպված է լինում նորից ու նորից կանչել native գրադարանը։ Սա զգալի ծախս է ավելացնում Java աշխարհի և native աշխարհի միջև վիճակը փոխելու հետ կապված «արարողակարգի» պատճառով։

libjava.so-ի ներսում հենց մաթեմատիկական գործողությունները կատարվեցին բավականին արագ՝

2.31%            libjava.so  Java_java_lang_Double_longBitsToDouble

Intrinsic-ները անջատված ControlIntrinsic-ով

Այստեղ մենք անջատեցինք intrinsic stub-ը միայն pow ֆունկցիայի համար և մնացած բոլոր intrinsic-ները թողեցինք տեղում։ Ինչպես նախորդ դեպքում, JVM-ը վերադարձավ FdLibm իրականացմանը՝

92.40%         c2, level 4  java.lang.FdLibm$Pow::compute, version 2, compile id 670

Այս անգամ սակայն JVM-ի տրամադրության տակ ավելի շատ օպտիմիզացիայի գործիքներ կային։ Այն, օրինակ, դեռ կարող էր intrinsify անել doubleToRawLongBits և longBitsToDouble, նախորդ օրինակի հիմնական խցանումները։ Արդյունքում այս թվերը ցույց են տալիս սովորական FdLibm pow իրականացումը գործարկելու իրական ժամանակը՝ առանց JNI ծախսի, որ տեսանք նախկինում։

Intrinsic-ները անջատված UseLibmIntrinsic-ով

Սա ամենաշփոթեցնող դեպքն է։ Թեև լոգերը պնդում էին, որ pow ֆունկցիան intrinsify է եղել, profiler-ը այլ պատկեր ցույց տվեց՝

92.01%           libjvm.so  SharedRuntime::dpow

Կատարման ժամանակի մեծ մասը ծախսվել է native գրադարանի ներսում։

Իմ հետաքննությունս ինձ հասցրեց inline_math_pow ֆունկցիային։ Սկզբնական ստուգումներից հետո դրա վերջին return հայտարարությունն ունի այսպիսի տեսք՝

return StubRoutines::dpow() != nullptr ?
  runtime_math(OptoRuntime::Math_DD_D_Type(), StubRoutines::dpow(),  "dpow") :
  runtime_math(OptoRuntime::Math_DD_D_Type(), CAST_FROM_FN_PTR(address, SharedRuntime::dpow),  "POW");

Երբ stub ռուտինը կոմպիլյացվել է, JVM-ը ընտրում է այդ stub-ը. ենթադրում եմ՝ լիովին օպտիմիզացված ճանապարհում հենց դա էլ տեղի է ունեցել։ Սակայն երբ stub գոյություն չունի, այն վերադառնում է SharedRuntime::dpow-ին։ Այս fallback-ը հենվում է JVM-ի թեթև ներքին կանչի վրա, որը շրջանցում է սովորական native JNI կանչերի սովորական ծախսը։

Ես նաև գտա համապատասխան մակրոն և մեթոդի իրականացումը՝

JRT_LEAF(jdouble, SharedRuntime::dpow(jdouble x, jdouble y))
  return __ieee754_pow(x, y);
JRT_END

Սա հաստատում է իմ վարկածի առաջին մասը. ֆունկցիան կոմպիլյացվել է libjvm.so-ի մեջ և կանչվել է որպես fallback, քանի որ stub-ը հասանելի չէր։ Թվում է՝ լոգը pow ֆունկցիան նշում է որպես «intrinsified» նախքան JVM-ը որոշել է, թե որ կոնկրետ իրականացումը C2 կոմպիլյատորը վերջնականապես կընտրի։

Սա դեռ վարկած է, որը լրացուցիչ հետազոտության կարիք ունի, բայց ավելի խորը ուսումնասիրությունը թողնում եմ ավելի ուշի համար՝ որպեսզի էլի մեկ «ճագարի բնի» մեջ չընկնեմ։

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

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

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