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

Ողջունեք Panama-ին

JEP-454-ի շնորհիվ Foreign Function & Memory (FFM) API-ը դարձավ կայուն հնարավորություն։ JDK 22-ից սկսած՝ մշակողները կարող են օգտագործել այս API-ը առանց լրացուցիչ կարգավորումների կամ «ձևաչափումների»։ Այս հոդվածը դիտարկում է, թե ինչպես է FFM API-ը պարզեցնում բնիկ գրադարանների հետ աշխատանքը և բարելավում արտադրողականությունը։

9 րոպե
JavaJVMProject Panama

JEP-454-ի շնորհիվ Foreign Function & Memory (FFM) API-ը դարձավ կայուն հնարավորություն։ JDK 22-ից սկսած՝ մշակողները կարող են օգտագործել այս API-ը առանց լրացուցիչ կարգավորումների կամ «ձևաչափումների»։ Այս հոդվածը դիտարկում է, թե ինչպես է FFM API-ը պարզեցնում բնիկ գրադարանների հետ աշխատանքը և բարելավում արտադրողականությունը։

Կարգավորում

Կոդը Java-ով է, բայց ես այն գործարկել եմ Scala-CLI-ով, քանի որ այն պարզ է պահում ամեն ինչ։ Benchmark-երը գործարկվել են Intel(R) Xeon(R) @ 2.20GHz մեքենայի վրա՝ 4 vCPUs (2 cores), 16GB RAM, Debian GNU/Linux 12 (bookworm)-ի վրա՝ OpenJDK Runtime Environment Temurin-25.0.1+8 (build 25.0.1+8-LTS)-ով։

Օրինակ

Այս առավելությունները ցույց տալու համար կօգտագործեմ libm.so գրադարանի pow ֆունկցիան։ Արդար համեմատության համար նախ տեսնենք, թե ինչպես է այս ֆունկցիան կանչվում դասական JNI API-ի միջոցով։

JNI

Բնիկ ֆունկցիայի կանչը JNI API-ով ներառում է ձեռքով կատարվող մի շարք քայլեր։

Սկզբում հայտարարում ենք Java մեթոդ native հիմնաբառով, որը ծառայում է որպես բնիկ իրականացման փոխարինող.

public static native double calculate(double base, double exponent);

Օրինակը օգտագործում է static մեթոդ, բայց դա խիստ անհրաժեշտ չէ։ Այդուհանդերձ, մեթոդի static լինելը կամ չլինելը ազդում է այն բանի վրա, թե որ պարամետրերն են փոխանցվում բնիկ ֆունկցիային (այս մասին՝ քիչ հետո)։

Այնուհետև Java կոմպիլյատորով գեներացնում ենք C/C++ header ֆայլ։ Այս ֆայլը ծառայում է որպես «կամուրջ» Java-ի և C-ի միջև.

javac -h native/ src/main/java/methods/JNIPowerCalculator.java

Այս հրամանը Java Compiler-ին ասում է փնտրել native մեթոդներ JNIPowerCalculator.java-ում և header ֆայլ գրել native/ դիրեկտորիայում։ Մեր ֆունկցիայի համար ստացված հայտարարությունը հետևյալն է.

JNIEXPORT jdouble JNICALL Java_methods_JNIPowerCalculator_calculate
  (JNIEnv *, jclass, jdouble, jdouble);
  • JNIEXPORT – մակրո, որը ֆունկցիան տեսանելի է դարձնում JVM-ին։
  • jdouble – վերադարձվող տիպը՝ ինչպես այն արտապատկերվում է JNI-ով (Java-ի double-ի համապատասխանը)։
  • JNICALL – մակրո, որը երաշխավորում է կանչի ճիշտ կոնվենցիան (որը տարբերվում է օպերացիոն համակարգերի միջև, օր.՝ Windows-ը՝ Linux-ից)։
  • Java_methods_JNIPowerCalculator_calculate-ը մեթոդի անունն է, որը պետք է ենթարկվի խիստ անվանման կոնվենցիայի.

a) Java_

b) package_

c) class_

d) մեթոդի անուն

  • JNIEnv * – JNI միջավայրի ցուցիչ, որն օգտագործվում է JVM-ի հետ փոխազդելու համար (օր.՝ Java օբյեկտներ ստեղծելու կամ բացառություններ նետելու համար)։
  • jclass – մեթոդը պարունակող դասի հղում։ Ոչ static մեթոդի դեպքում այս պարամետրը փոխարենը կլիներ jobject (կոնկրետ օրինակի հղում)։
  • Վերջապես, կան երկու jdouble արգումենտներ, որոնք ֆունկցիայի արգումենտներն են։

Հաջորդը C-ի իրական իրականացումն է, որն այստեղ պարզապես պատվիրակում է ստանդարտ մաթեմատիկական գրադարանին.

JNIEXPORT jdouble JNICALL Java_methods_JNIPowerCalculator_calculate
  (JNIEnv *env, jclass clazz, jdouble base, jdouble exponent) {
    return pow(base, exponent);
}

Վերջում C կոդը պետք է կոմպիլացվի shared գրադարանի, որը JVM-ը կարող է բեռնել.

gcc -shared -fPIC \
 -I"$JAVA_HOME/include" \
 -I"$JAVA_HOME/include/linux" \
 native/PowerCalculator.c -o lib/libnative-power-calculator.so -lm
  • -shared – արտադրում է shared գրադարան (.so)՝ գործարկվող ֆայլի փոխարեն։
  • -fPIC – արտադրում է Position Independent Code, որը Linux-ում shared գրադարաններին անհրաժեշտ է, որպեսզի դրանք կարողանան բեռնվել հիշողության ցանկացած հասցեում՝ առանց բախումների։
  • -I – կոմպիլյատորին ցույց է տալիս անհրաժեշտ header ֆայլերը։
  • -o – սահմանում է ելքային ուղին և ֆայլի անունը։
  • -lm – կապակցում է ստանդարտ մաթեմատիկական գրադարանը (m), որպեսզի pow ֆունկցիան կարողանա օգտագործվել։

Ակնհայտ է, որ նույնիսկ չնչին բնիկ ֆունկցիա կանչելը պահանջում է շատ «boilerplate» կոդ և արտաքին գործիքներ։ Բնիկ ֆունկցիան ուղղակի կանչելու միջոց չկա. պետք է գրել և կոմպիլացնել wrapper, որը բավարարում է JNI-ի խիստ անվանման և պարամետրերի կանոնները։

Տեսնենք հիմա, թե ինչպես է FFM API-ը փոխել իրավիճակը։

Project Panama

Foreign Function & Memory (FFM) API-ի շնորհիվ նույն pow ֆունկցիան կարելի է կանչել զուտ Java-ից, առանց որևէ C «glue» կոդի։ Ամեն ինչ սկսվում է MethodHandle ստանալով։ Օրինակ կոդը կարող է այսպիսին լինել.

public class PanamaPowerCalculator {
    private static final MethodHandle METHOD_HANDLE;

    static {
        (1) Linker linker = Linker.nativeLinker();
        Map<String, MemoryLayout> layouts = (3) linker.canonicalLayouts();
        (5) MemorySegment symbol = linker.defaultLookup().find("pow").get();
        (2) ValueLayout cDouble = (ValueLayout) layouts.get("double");
        (4) FunctionDescriptor fd = FunctionDescriptor.of(cDouble, cDouble, cDouble);
        (6) METHOD_HANDLE = linker.downcallHandle(symbol, fd);
    }
    ...
}
  1. Linker – հասանելիություն է տալիս օտար ֆունկցիաներին։
  2. ValueLayout – նկարագրում է հիմնական տվյալների տիպերի չափը և հավասարեցումը (alignment), օր.՝ Integer, Long, ….
  3. canonicalLayouts – տրամադրում է C տվյալների տիպերի ստանդարտ layout-ները հիմքում ընկած օպերացիոն համակարգի և պրոցեսորի համար։ Սա կարևոր է, քանի որ դրանք կարող են տարբերվել օպերացիոն համակարգերի միջև, օր.՝ Windows-ում long-ը սովորաբար 32 բիթ է, մինչդեռ Linux-ում՝ 64 բիթ։
  4. FunctionDescriptor – նկարագրում է օտար ֆունկցիայի ստորագրությունը։ Առաջին արգումենտը վերադարձվող տիպի layout-ն է, իսկ հաջորդ երկուսը՝ արգումենտների layout-ները։
  5. MemorySegment – հասանելիություն է տալիս հիշողության հարակից տիրույթներին. այստեղ՝ pow ֆունկցիային։
  6. MethodHandle – օտար ֆունկցիայի հղում, որը կարելի է ուղղակի կատարել։

Վերը բերված օրինակը կատարում է downcall (բնիկ ֆունկցիայի կանչ Java-ից)։ Ուշագրավ է, որ FFM API-ն աջակցում է նաև հակառակ ուղղությունը՝ upcalls։

upcallStub-ի միջոցով Java method handle-ը կարելի է փոխանցել բնիկ կոդին որպես ֆունկցիայի ցուցիչ, ինչը թույլ է տալիս C կոդին «հետ կանչել» ձեր Java հավելվածը։ Այս հոդվածը, սակայն, անդրադառնում է միայն downcall դեպքին։

Այն բանից հետո, երբ MethodHandle-ը downcall-ի համար սկզբնավորվել է, այն կարելի է կատարել invoke կամ invokeExact մեթոդով։

invoke մեթոդը ներողամիտ է։ Երբ փոխանցված արգումենտները ճշգրտորեն չեն համապատասխանում FunctionDescriptor-ին, JVM-ը փորձում է տիպերը ավտոմատ փոխարկել՝ նախքան բնիկ կանչը կատարելը։

public static double calculateInvokeWithConversion(int base, int exponent) {
   try {
      return (double) METHOD_HANDLE.invoke(base, exponent);
   } catch (Throwable t) {
      throw new RuntimeException(t);
   }
}

invokeExact մեթոդը, ընդհակառակը, պահանջում է, որ տիպերը ճշգրտորեն համապատասխանեն FunctionDescriptor-ին։ Սխալ տիպի արգումենտ փոխանցելը հանգեցնում է անմիջական WrongMethodTypeException-ի։

public static double calculateInvokeExact(double base, double exponent) {
   try {
      return (double) METHOD_HANDLE.invokeExact(base, exponent);
   } catch (Throwable t) {
      throw new RuntimeException(t);
   }
}

FFM մոտեցումը զգալիորեն ավելի մաքուր է և ավելի հեշտ պահպանվող, քան JNI-ը։ Այն վերացնում է C header-ները, արտաքին կոմպիլյատորները և «glue» կոդը, ուստի ամբողջ տրամաբանությունը մնում է Java էկոհամակարգի ներսում։

Կարո՞ղ ենք, սակայն, է՛լ ավելի հեռու գնալ։ Հաջորդ բաժինը ցույց է տալիս, թե ինչպես jextract-ը կարող է ավտոմատացնել ամբողջ գործընթացը։

Jextract

MethodHandle-ի և FunctionDescriptor-ի տրամաբանությունը ձեռքով գրելը լավ է pow-ի նման մեկ ֆունկցիայի համար, բայց ավելի մեծ գրադարանների համար դառնում է հոգնեցուցիչ և սխալների հակված։ Այստեղ է, որ գործի է անցնում jextract-ը։

jextract գործիքը ավտոմատ կերպով գեներացնում է Java կապակցումներ (bindings) բնիկ գրադարանների header-ներից։ Ուշագրավ է, որ թեև այն սկսվել է OpenJDK-ի ներսում, այժմ պահպանվում է որպես առանձին գործիք, որպեսզի կարողանա զարգանալ հիմնական JDK թողարկման ցիկլից անկախ։

Այն օգտագործելու համար ձեզ կպետք լինի jextract երկուական ֆայլը։ Այս հրամանը գեներացնում է Java wrapper pow ֆունկցիայի համար.

jextract --output src/main/java \
-t math \
/usr/include/math.h \
--header-class-name NativeMath \
--include-function pow
  • --output – գեներացված սկզբնական ֆայլերի թիրախ դիրեկտորիան։
  • -t – թիրախ Java փաթեթի անունը։
  • /usr/include/math.h – վերլուծվող header ֆայլը։
  • --header-class-name – Java դասի անունը, որը կպարունակի բնիկ մեթոդները։
  • --include-function – նեղացնում է գեներացվողը։ Առանց դրա jextract-ը կփորձեր կապակցումներ գեներացնել math.h-ի յուրաքանչյուր ֆունկցիայի համար։

Սովորաբար հրամանը արտադրում է երկու հիմնական ֆայլ.

  • NativeMath.java – բացահայտում է բարձր մակարդակի Java մեթոդները, որոնք ուղղակի կանչում եք, ծառայելով որպես բնիկ գրադարանի հիմնական ինտերֆեյս։
  • NativeMath$shared.java – պարունակում է կուլիսների հետևում գտնվող «խողովակաշարը», ինչպիսին է հիշողության layout-ները, որոնք JVM-ին ասում են, թե ինչպես վարվել բնիկ տվյալների տիպերի հետ։

JNI-ն, ձեռքով գրված Panama-ն և jextract-ով գեներացված Panama-ն ընդգրկելուց հետո համեմատենք դրանց արտադրողականությունը և ստուգենք՝ արդյոք «boilerplate»-ը իրոք ազդում է արագության վրա։

Համեմատություն

Այս մոտեցումների արդյունավետությունը չափելու համար ես գործարկեցի JMH benchmark՝ համեմատելով հինգ իրականացում.

  • JNI API. Դասական բնիկ կամուրջը։
  • Panama invokeExact։
  • Panama invoke (With Conversion). int արգումենտները փոխանցվում են double ստորագրությանը։
  • Panama invoke (Matching Types). double արգումենտները փոխանցվում են ուղղակի
  • jextract. Հենվում է ավտոմատ գեներացված կապակցումների վրա։

Benchmark-ի արդյունքները.

Benchmark                                                                              Mode  Cnt   Score   Error  Units
NativeMethodCallBenchmark.benchmark_JNI_Power_Calculator                               avgt   15  34.659 ? 0.198  ns/op
NativeMethodCallBenchmark.benchmark_Panama_Invoke_Exact_Power_Calculator               avgt   15  29.541 ? 0.222  ns/op
NativeMethodCallBenchmark.benchmark_Panama_Invoke_With_Conversion_Power_Calculator     avgt   15  34.310 ? 0.312  ns/op
NativeMethodCallBenchmark.benchmark_Panama_Invoke_Without_Conversion_Power_Calculator  avgt   15  29.554 ? 0.138  ns/op
NativeMethodCallBenchmark.benchmark_Panama_J_Extract_Power_Calculator                  avgt   15  29.413 ? 0.067  ns/op

Արդյունքների համաձայն՝ invokeExact-ը, invoke-ը (համընկնող տիպերով) և jextract-ը գրեթե հավասար առաջատար են՝ ~29.5 ns։ Մնացած տարբերակները մոտ 5ns (17%) ավելի դանդաղ են։

Այդ 29.5 ns-ը, սակայն, ներառում է նաև libm.so-ում հենց pow հաշվարկի վրա ծախսված ժամանակը։ Java-ից բնիկ կոդի անցման իրական արժեքը գտնելու համար ես benchmark-ը գործարկեցի perfasm պրոֆայլերով.

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

Պրոֆայլերի ծախսը թվերը մի փոքր փոխեց, բայց ընդհանուր օրինաչափությունը մնաց նույնը.

Benchmark                                                                                  Mode  Cnt   Score    Error  Units
NativeMethodCallBenchmark.benchmark_JNI_Power_Calculator                                   avgt    5  35.050 ?  3.193  ns/op
NativeMethodCallBenchmark.benchmark_Panama_Invoke_Exact_Power_Calculator                   avgt    5  30.336 ?  7.101  ns/op
NativeMethodCallBenchmark.benchmark_Panama_Invoke_With_Conversion_Power_Calculator         avgt    5  36.807 ? 12.709  ns/op
NativeMethodCallBenchmark.benchmark_Panama_Invoke_Without_Conversion_Power_Calculator      avgt    5  29.660 ?  0.335  ns/op
NativeMethodCallBenchmark.benchmark_Panama_J_Extract_Power_Calculator                      avgt    5  30.168 ?  6.217  ns/op

Պրոֆայլերի ելքը ցույց տվեց, որ libm.so-ում հենց մաթեմատիկական գործողությունը տևում է մոտ 17 ns։ Այս «աշխատանքային ժամանակը» ընդհանուրից հանելով՝ ստանում ենք.

  • Panama-ի overhead. ~12.5 ns
  • JNI/Conversion overhead. ~17.5 ns

Այս տեսանկյունից ամենաարագ Panama լուծումները կանչի զուտ overhead-ով հաղթում են ավելի դանդաղներին մոտ 30%-ով։

Բնականաբար, սա վերաբերում է միայն այսպիսի պարզ օրինակին։ Եթե մեր բնիկ գրադարանը այլ տեսակի աշխատանք կատարեր, շահույթը կլիներ որոշ չափով ավելի մեծ կամ փոքր՝ կախված այն բանից, թե «աշխատանքը» ինչպես է համեմատվում «կանչի overhead»-ի հետ։ Այդուհանդերձ, փորձենք հասկանալ, թե ինչու են որոշ լուծումներ ավելի արագ, քան մյուսները։

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

jhsdb-ով վրիպազերծումը պարզեցնելու համար ես նախագծին ավելացրի Main դաս։ Կոդը, որ JIT-ը կոմպիլացնում է սովորական հավելվածում, միշտ չէ, որ նույնն է, ինչ JMH-ի խիստ օպտիմիզացված կոդը, բայց այն լավ պատկերացում է տալիս, թե JVM-ն ինչպես է վարվում այս կանչերի հետ։

Երեք ամենաարագ լուծումների (invokeExact, invoke – առանց փոխարկման, և jextract) համար գեներացված assembly-ն շատ նման է.

0x00007fa5dfef0166:    movabs $0x7fa5f7a682b0,%rsi
...
0x00007fa5dfef0178:    movabs $0x7157a5328,%rdx
0x00007fa5dfef0182:    nop
0x00007fa5dfef0183:    call   0x00007fa5dfede980
  • rsi ռեգիստրը պարունակում է pow ֆունկցիայի հիշողության հասցեն։
  • rdx ռեգիստրը պարունակում է NativeEntryPoint հասցեն։
  • NativeEntryPoint-ը պահում է հղում nep_invoker_blob-ին՝ նվիրված stub-ին, որը բնիկ ֆունկցիա անցումը կատարում է շատ քիչ լրացուցիչ հրահանգներով։

JNI-ի դեպքում JVM-ը արտադրում է native_wrapper։ Ինչպես nep_invoker_blob-ը, այն կամրջում է JVM-ը և օտար ֆունկցիան, բայց շատ ավելի քիչ օպտիմիզացված է։ Դրան գումարած՝ մեր սեփական C wrapper-ը բերում է overhead-ի լրացուցիչ շերտ, որը JIT-ը չի կարող օպտիմիզացնել։

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

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

Foreign Function & Memory (FFM) API-ը զգալիորեն պարզեցնում է բնիկ գրադարանների հետ փոխազդեցությունը։ Ինչպես ցույց են տալիս մեր benchmark-երը, այս պարզությունը բերում է նաև ավելի լավ արտադրողականություն։ Քանի որ JIT կոմպիլյատորը կարող է օպտիմիզացնել կանչի ուղին ուղղակիորեն, FFM API-ը կրճատում է կանչի overhead-ը մոտ 30%-ով (ինչպես վերևում ցույց տրվեց)՝ դասական JNI-ի համեմատ։

Անկախ նրանից՝ հենվում եք jextract-ի վրա ավտոմատացման համար, թե MethodHandle-ի վրա՝ ձեռքով վերահսկողության համար, դուք ստանում եք ավելի արագ, ավելի անվտանգ և ավելի հեշտ պահպանվող եղանակ՝ ժամանակակից Java-ում բնիկ կոդն օգտագործելու համար։

Հուսով եմ՝ այս հոդվածը ձեզ օգտակար կլինի։