تقدير المشروع
← كل المقالات

الأحصنة العاملة في JVM: الـ Stubs والـ Intrinsics

يصف هذا المقال ما هي الـ stubs ولماذا تُعدّ بهذه الأهمية داخل JVM.

10 دقائق قراءة
JavaJVMأسرار Java الداخليةIntrinsicsStubs

قبل عدة أسابيع، كنت أفحص مسارًا ساخنًا (hot path) في المشروع الذي أعمل عليه حاليًا. كانت الشيفرة تجري عددًا من الاستدعاءات لهذه الدالة:

System.arracopy(args...)

وبناءً على ذلك، شككت في أن النمط قد لا يكون الأمثل، افتراضًا مني أن النسخ يتطلب استدعاءً مكلفًا لمكتبة أصلية (native). وقد نبع افتراضي من توقيع الدالة:

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

لكن حين نظرت إلى شيفرة الآلة التي أنتجها C2، لاحظت عدة استدعاءات لـ Final Stub.

وفي ضوء هذه النتائج، يشرح هذا المقال ما هي الـ stubs ولماذا هي مهمة جدًا داخل 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 cores), 16GB RAM، ويعمل بنظام Debian GNU/Linux 12 (bookworm).

وللاختبار، اعتمدت على نسخة Adoptium المرآة لمستودع OpenJDK عند الوسم jdk-25.0.2+10.

الـ Stubs

الـ Stubs هي مقاطع من شيفرة التجميع (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

يُظهر هذا أن توليد روتينات الـ stubs مقسّم إلى عدة خطوات منفصلة:

  • Initial stubs
  • Continuation stubs
  • Compiler stubs
  • Final stubs

وبما أن بعض الـ stubs يعتمد على غيره، فإن هذا الترتيب أساسي لتوليدها بشكل صحيح.

وللتحقق من المدة التي يستغرقها توليد الـ stubs، يمكننا تشغيل الأمر التالي:

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 stubs – استغرقت نحو 3 ms، وانتهت بقية المراحل في غضون ميكروثوانٍ.

ويمكن أيضًا فحص شيفرة التجميع المولَّدة بتفعيل الخيار -XX:+PrintStubCode.

وكما توضح الوثائق في stubRoutines.hpp، فرغم أن كل خطوة (initial وfinal وغيرهما) قد تنتج كثيرًا من الـ stubs، فإنها كلها تنتهي في BufferBlob واحد، يحتوي ببساطة على نقاط دخول متعددة. وهذا بخلاف الـ stubs (المعروفة أيضًا بـ blobs) التي يولّدها SharedRuntime، إذ يُحزَّم كل منها في BufferBlob خاص به.

والـ BufferBlob حاوية تحتفظ بشيفرة آلة محفوظة في Code Cache.

وللـ stubs سمة مثيرة أخرى تجعلها أكثر كفاءة: فبعضها يمكن تجميعه باستخدام intrinsics.

الـ Intrinsics

يمكنك أن تتخيل الـ intrinsics شيفرة تجميع متخصصة مكتوبة خصيصًا لمعمارية معالج معينة. وتستفيد الدالة intrinsic من تعليمات معينة من Instruction Set Architecture (ISA)، وهي تختلف من معالج إلى آخر.

ورغم أن القائمة الكاملة للـ intrinsics المتاحة معرّفة في vmIntrinsics.hpp، فليس كل منها منفذًا لكل معمارية معالج. ولهذا يجب تنفيذ 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;
}

للبدء، يمكننا سرد الـ intrinsics التي يستخدمها البرنامج بإضافة الخيار 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. لكن هناك أيضًا طرقًا لإيقاف الـ intrinsics، أتناولها فيما يلي.

تعطيل InlineNatives

أول خيار متاح لنا هو إيقاف InlineNatives. فحين يُعطَّل هذا الإعداد ويُشغَّل البرنامج هكذا:

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

تتوقف الدالة pow عن أن تُعامَل كـ intrinsic. وتُظهر السجلات بدلًا من ذلك أن بعض الدوال جرى تضمينها (inlined)، لكن لم تُعامَل أي منها كـ intrinsic:

@ 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

لننظر مرة أخرى إلى الـ stubs المولَّدة. فمع إيقاف InlineNatives، يتخطى JVM إنشاء stubs لكثير من الدوال، منها pow وsin وdoubleToRawLongBits. ويمكن الحصول على القائمة الكاملة للدوال المتأثرة بفحص الدالة vmIntrinsics::disabled_by_jvm_flags.

والأهم أنه مع تفعيل هذا الخيار لا يُنتَج أي stub إطلاقًا، فلا تشغل أي ذاكرة في Code Cache.

ControlIntrinsic

بينما يعمل العلم السابق «على مستوى عام» – فيوقف كثيرًا من الـ stubs دفعة واحدة – يمنحنا الخيار ControlIntrinsic تحكمًا أدق بكثير (ويوجد أيضًا خيار DisableIntrinsic، لكن الوثائق في vmIntrinsics.hpp تقول إنه سيُهمَل قريبًا).

ولإيقاف الـ intrinsics للدالة pow وحدها، علينا تقديم معرّف intrinsic الخاص بتلك الدالة. ويمكننا البحث عنه في الملف vmIntrinsics.hpp، الذي يتضمن لكل intrinsic شيفرة على غرار:

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

والمعرّف الذي نبحث عنه هو الوسيط الأول، _ 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

نرى أن عدة دوال جرى تضمينها، لكن abs بقيت intrinsic. بعبارة أخرى، يتيح لنا هذا النهج إيقاف intrinsic واحد مع إبقاء البقية مفعّلة. وتؤكد ذلك الـ stubs المولَّدة: فالـ stub الخاص بـ pow وحده غائب.

استخدام خيارات محددة

وهناك طريقة أخرى لإيقاف intrinsics معينة، هي علم مخصص لدالة واحدة أو مجموعة دوال. ولسرد جميع الخيارات المتاحة، يمكننا تشغيل هذا الأمر:

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)

وهي تطابق الناتج الذي نحصل عليه مع تفعيل كل الـ intrinsics. ومع ذلك، تُظهر نظرة على الـ stubs المولَّدة أن الـ stubs الخاصة بالدالة pow – وبدوال رياضية أخرى مثل sin أو log – لم تُولَّد.

وليست هذه المرة الأولى التي يُريني فيها JVM أنه كلما اعتقدت أنني فهمت سلوكه، يبقى الكثير مما عليّ تعلمه. ولن أحاول تقديم تفسير قاطع لسبب تصرف الخيار PrintIntrinsics بهذه الطريقة. بل سأشارك بضع تخمينات مدروسة مستمدة مما وجدته.

ولمعرفة ما يجري فعلًا تحت الغطاء، كتبت بضعة اختبارات أداء (benchmarks).

اختبارات الأداء

تقارن اختبارات الأداء التي كتبتها كل النهج التي نوقشت أعلاه:

@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

تُظهر الأرقام بوضوح أن الدالة pow المعامَلة كـ intrinsic تتفوق على كل البدائل بفارق كبير. أما النسخة مع إيقاف الخيار InlineNatives فهي، بلا أدنى شك، الأبطأ. ومن المثير للاهتمام أن النسختين المتبقيتين تؤديان بشكل متطابق تقريبًا.

تحليل الأداء

لفهم ما يشغّله JVM بالضبط في كل حالة بصورة أعمق، نفّذت اختبارات الأداء مع تفعيل محلل أداء (profiler)، باستخدام هذا الأمر:

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

الـ Intrinsics مفعّلة

هذه الحالة سهلة التحليل، لأن معظم وقت التنفيذ ذهب في استدعاء الـ stub المولَّد للدالة pow:

88.14%          runtime stub  StubRoutines::dpow

الأداء جيد لأنه لا توجد استدعاءات دوال زائدة والشيفرة محسَّنة بالكامل.

الـ Intrinsics معطَّلة بواسطة 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

وبما أن هذا الخيار يوقف نطاقًا واسعًا من الـ intrinsics، يلجأ JVM إلى تنفيذ FdLibm للدالة pow (وهو نقل إلى Java لمكتبات الرياضيات بلغة C بُني مراعاةً للقابلية للنقل لا للأداء).

لكن معظم الوقت ذهب في دالتين من الفئة Double:

  • doubleToRawLongBits
  • longBitsToDouble

وهما دالتان أصليتان (native) كانتا ستُعاملان عادةً كـ intrinsics، ولذا مع إيقاف هذه الميزة، يضطر JVM إلى استدعاء المكتبة الأصلية مرارًا وتكرارًا. وهذا يضيف عبئًا كبيرًا بسبب «الطقوس» المتضمنة في تبديل الحالة بين عالم Java والعالم الأصلي.

أما العمليات الرياضية نفسها داخل libjava.so فقد جرت بسرعة كبيرة:

2.31%            libjava.so  Java_java_lang_Double_longBitsToDouble

الـ Intrinsics معطَّلة بواسطة ControlIntrinsic

هنا، أوقفنا الـ stub الخاص بالـ intrinsic للدالة pow وحدها وأبقينا كل الـ intrinsics الأخرى في مكانها. وكما في الحالة السابقة، لجأ JVM إلى تنفيذ FdLibm:

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

لكن هذه المرة، كانت لدى JVM أدوات تحسين أكثر متاحة. فقد كان بإمكانه، مثلًا، أن يظل يعامل doubleToRawLongBits وlongBitsToDouble كـ intrinsics، وهما الاختناقان الرئيسيان في المثال السابق. ونتيجة لذلك، تُظهر هذه الأرقام الوقت الحقيقي اللازم لتشغيل تنفيذ FdLibm العادي للدالة pow، دون عبء JNI الذي رأيناه سابقًا.

الـ Intrinsics معطَّلة بواسطة UseLibmIntrinsic

هذه هي الحالة الأكثر إثارة للحيرة. فرغم أن السجلات ادّعت أن الدالة pow عُوملت كـ intrinsic، رسم المحلل صورة مختلفة:

92.01%           libjvm.so  SharedRuntime::dpow

أُنفق معظم وقت التنفيذ داخل المكتبة الأصلية.

قادني تحقيقي إلى الدالة inline_math_pow. وبعد الفحوصات الأولية، تبدو عبارة الإرجاع الأخيرة فيها هكذا:

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. ويعتمد هذا البديل على استدعاء داخلي خفيف في JVM، يتجنب العبء المعتاد لاستدعاءات JNI الأصلية العادية.

كما تتبعت الماكرو المقابل وتنفيذ الدالة:

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

وهذا يدعم الجزء الأول من فرضيتي: فقد جُمّعت الدالة داخل libjvm.so واستُدعيت بديلًا لأن الـ stub لم يكن متاحًا. ويبدو أن السجل يصنّف الدالة pow على أنها «intrinsic» قبل أن يقرر JVM أي تنفيذ محدد سيختاره مترجم C2 في النهاية.

ولا تزال هذه فرضية تحتاج إلى مزيد من البحث، لكنني سأترك التحقيق الأعمق لوقت لاحق كي لا أقع في «جحر أرنب» آخر.

الخاتمة

أردت بهذا المقال أن أشرح كيف تعمل الـ stubs والـ intrinsics. فهي ليست ميزات جديدة؛ بل على العكس، هي آليات مستقرة وناضجة ظلت جزءًا أساسيًا من JVM لسنوات عديدة.

وقد لا يكون كثير من المطورين على دراية كبيرة بها – غالبًا لأنها تعمل بسلاسة في الخلفية – لكن معرفتها تمنح رؤية أوضح لكيفية بلوغ JVM هذا الأداء العالي في المسارات الحرجة من الشيفرة. آمل أن تكون وجدت هذا المقال مفيدًا.