Ողջունեք Panama-ին
JEP-454-ի շնորհիվ Foreign Function & Memory (FFM) API-ը դարձավ կայուն հնարավորություն։ JDK 22-ից սկսած՝ մշակողները կարող են օգտագործել այս API-ը առանց լրացուցիչ կարգավորումների կամ «ձևաչափումների»։ Այս հոդվածը դիտարկում է, թե ինչպես է FFM API-ը պարզեցնում բնիկ գրադարանների հետ աշխատանքը և բարելավում արտադրողականությունը։
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);
}
...
}
Linker– հասանելիություն է տալիս օտար ֆունկցիաներին։ValueLayout– նկարագրում է հիմնական տվյալների տիպերի չափը և հավասարեցումը (alignment), օր.՝ Integer, Long, ….canonicalLayouts– տրամադրում է C տվյալների տիպերի ստանդարտ layout-ները հիմքում ընկած օպերացիոն համակարգի և պրոցեսորի համար։ Սա կարևոր է, քանի որ դրանք կարող են տարբերվել օպերացիոն համակարգերի միջև, օր.՝ Windows-ում long-ը սովորաբար 32 բիթ է, մինչդեռ Linux-ում՝ 64 բիթ։FunctionDescriptor– նկարագրում է օտար ֆունկցիայի ստորագրությունը։ Առաջին արգումենտը վերադարձվող տիպի layout-ն է, իսկ հաջորդ երկուսը՝ արգումենտների layout-ները։MemorySegment– հասանելիություն է տալիս հիշողության հարակից տիրույթներին. այստեղ՝powֆունկցիային։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-ում բնիկ կոդն օգտագործելու համար։
Հուսով եմ՝ այս հոդվածը ձեզ օգտակար կլինի։