اختبار تدفقات Java بمقاييس الأداء
بعد أن نظرنا في واجهة Java ExecutorService وتطبيقاتها، نختبر الآن كيف يتعامل إطار Fork/Join وThreadPerTaskExecutor مع الضغط.
في المقال السابق فحصت عن كثب واجهة Java ExecutorService وتطبيقاتها، مع إيلاء اهتمام خاص لإطار Fork/Join وThreadPerTaskExecutor. هذه المرة أريد أن أخطو خطوة أبعد وأرى كيف يتعاملان مع الضغط. وببساطة، سأشغّل اختبارات أداء – وبأعداد كبيرة.
المنطق قيد الاختبار
دعوني أبدأ باستعراض المنطق الذي بُنيت عليه اختبارات الأداء، فهو ينقسم إلى فئتين أساسيتين:
- قائم على التدفق الكلاسيكي (classic stream)
- قائم على نهج Fork/Join
منطق التدفق الكلاسيكي
public static Map<Ip, Integer> groupByIncomingIp(Stream<String> requests,
LocalDateTime upperTimeBound, LocalDateTime lowerTimeBound) {
return requests
.map(line -> line.split(","))
.filter(words -> words.length == 3)
.map(words -> new Request(words[1], LocalDateTime.parse(words[2])))
.filter(request -> request.timestamp().isBefore(upperTimeBound) &&
request.timestamp().isAfter(lowerTimeBound))
.map(i -> new Ip(i.ip()))
.collect(groupingBy(i -> i, summingInt(i -> 1)));
}
من حيث المبدأ، تأخذ هذه الشيفرة قائمة من السلاسل النصية، وتحوّلها، وتطبّق بعض التصفية والتجميع، وتُرجع خريطة (map). وتبدو السلاسل التي تستقبلها هكذا:
1,192.168.1.1,2023-10-29T17:33:33.647641574
تمثّل كل سلسلة حدثًا تحاول فيه عنوان IP الوصول إلى خادم معيّن. وتربط النتيجة كل عنوان IP بعدد محاولات الوصول خلال فترة زمنية معطاة، تحددها حدود زمنية دنيا وعليا.
منطق Fork/Join
@Override
public Map<Ip, Integer> compute() {
if (data.size() >= THRESHOLD) {
Map<Ip, Integer> output = new HashMap<>();
ForkJoinTask
.invokeAll(createSubTasks())
.forEach(task -> task
.join()
.forEach((k, v) -> updateOutput(k, v, output))
);
return output;
}
return process();
}
private void updateOutput(Ip k, Integer v, Map<Ip, Integer> output) {
Integer currentValue = output.get(k);
if (currentValue == null) {
output.put(k, v);
} else {
output.replace(k, currentValue + v);
}
}
private List<ForkJoinDefinition> createSubTasks() {
int size = data.size();
int middle = size / 2;
return List.of(
new ForkJoinDefinition(new ArrayList<>(data.subList(0, middle)), now),
new ForkJoinDefinition(new ArrayList<>(data.subList(middle, size)), now)
);
}
private Map<Ip, Integer> process() {
return groupByIncomingIp(data.stream(), upperTimeBound, lowerTimeBound);
}
الفرق الجوهري الوحيد هو أنني أواصل تقسيم مجموعة البيانات إلى دفعات أصغر حتى تبلغ حدًّا معينًا، قيمته الافتراضية 20. وعندها فقط أبدأ الحسابات، وهي مطابقة لحسابات منطق التدفق الكلاسيكي الموصوف سابقًا – إذ أعتمد على الدالة groupByIncomingIp.
إعداد JMH
كُتب كل اختبار أداء باستخدام Java Microbenchmark Harness (أو JMH اختصارًا).
شغّلت الاختبارات بالإصدار 1.37 من JMH. وتستخدم جميعها الإعداد نفسه: خمس دورات إحماء تليها عشرون دورة قياس.
يُستخدم وضعان مختلفان: متوسط الزمن والإنتاجية. في وضع متوسط الزمن، يقيس JMH متوسط زمن تنفيذ الشيفرة المختبَرة، وتُعطى النتيجة بالميلي ثانية.
وفي وضع الإنتاجية، يحسب JMH عدد العمليات - أي التنفيذات الكاملة للشيفرة - التي تتسع لها وحدة زمنية معطاة، وهي هنا الميلي ثانية. وتُعطى النتيجة بعدد العمليات لكل ميلي ثانية.
وبتعبيرات JMH:
@Warmup(iterations = 5, time = 10, timeUnit = SECONDS)
@Measurement(iterations = 20, time = 10, timeUnit = SECONDS)
@BenchmarkMode({Mode.AverageTime, Mode.Throughput})
@OutputTimeUnit(MILLISECONDS)
@Fork(1)
@Threads(1)
وإضافة إلى ذلك، لكل اختبار أداء State خاصة به بنطاق Benchmark تحتوي جميع البيانات والمتغيرات التي يحتاجها ذلك الاختبار.
حالة الاختبار (Benchmark State)
التدفق الكلاسيكي
ستجدون أدناه حالة الاختبار الأساسية للتدفق الكلاسيكي.
@State(Scope.Benchmark)
public class BenchmarkState {
@Param({"0"})
public int size;
public List<String> input;
public ClassicDefinition definitions;
public ForkJoinPool forkJoinPool_4;
public ForkJoinPool forkJoinPool_8;
public ForkJoinPool forkJoinPool_16;
public ForkJoinPool forkJoinPool_32;
private final LocalDateTime now = LocalDateTime.now();
@Setup(Level.Trial)
public void trialUp() {
input = new TestDataGen(now).generate(size);
definitions = new ClassicDefinition(now);
System.out.println(input.size());
}
@Setup(Level.Iteration)
public void up() {
forkJoinPool_4 = new ForkJoinPool(4);
forkJoinPool_8 = new ForkJoinPool(8);
forkJoinPool_16 = new ForkJoinPool(16);
forkJoinPool_32 = new ForkJoinPool(32);
}
@TearDown(Level.Iteration)
public void down() {
forkJoinPool_4.shutdown();
forkJoinPool_8.shutdown();
forkJoinPool_16.shutdown();
forkJoinPool_32.shutdown();
}
}
في البداية أهيّئ كل متغير تحتاجه الاختبارات. وباستثناء المعامل size الذي يلعب دورًا خاصًا هنا، تُستخدم مجمّعات الخيوط داخل الاختبار فقط.
أما المعامل size فهو، على العكس، آلية مثيرة للاهتمام يوفرها JMH. فهي تتيح لك ضبط متغير معيّن مستخدم أثناء الاختبار كمعامل. وعندما نصل لاحقًا إلى تشغيل الاختبارات ستلاحظون كيف استفدت منها.
في الوقت الحالي أعتمد على هذا المعامل لتوليد مجموعة بيانات الإدخال، التي تبقى كما هي طوال الاختبار - لتكون النتائج أكثر قابلية للتكرار.
بعد ذلك تأتي دالة up، التي تتصرف إلى حد كبير مثل @BeforeEach من مكتبة JUnit.
وهي تعمل قبل كل دورة من الدورات 20 لاختبار الأداء وتعيد ضبط جميع المتغيرات التي يستخدمها. وبهذه الطريقة تبدأ كل دورة بحالة نظيفة.
وأخيرًا هناك دالة down، التي تتصرف إلى حد كبير مثل @AfterEach من مكتبة JUnit.
وهي تعمل بعد كل دورة من الدورات 20 لاختبار الأداء وتغلق جميع مجمّعات الخيوط المستخدمة في تلك الدورة - بالأساس للتعامل مع تسرّبات الذاكرة المحتملة.
Fork/Join
هكذا تبدو الحالة لنسخة Fork/Join.
@State(Scope.Benchmark)
public class ForkJoinState {
@Param({"0"})
public int size;
public List<String> input;
public ForkJoinPool forkJoinPool_4;
public ForkJoinPool forkJoinPool_8;
public ForkJoinPool forkJoinPool_16;
public ForkJoinPool forkJoinPool_32;
public final LocalDateTime now = LocalDateTime.now();
@Setup(Level.Trial)
public void trialUp() {
input = new TestDataGen(now).generate(size);
System.out.println(input.size());
}
@Setup(Level.Iteration)
public void up() {
forkJoinPool_4 = new ForkJoinPool(4);
forkJoinPool_8 = new ForkJoinPool(8);
forkJoinPool_16 = new ForkJoinPool(16);
forkJoinPool_32 = new ForkJoinPool(32);
}
@TearDown(Level.Iteration)
public void down() {
forkJoinPool_4.shutdown();
forkJoinPool_8.shutdown();
forkJoinPool_16.shutdown();
forkJoinPool_32.shutdown();
}
}
لا يكاد يوجد اختلاف بين إعدادي التدفق الكلاسيكي وFork/Join. الفرق الوحيد هو أن التعريفات تُنشأ داخل الاختبارات نفسها لا في الحالة (state)، كما هو الحال في النهج الكلاسيكي.
ويعود هذا التغيير إلى طريقة عمل RecursiveTask - إذ تُخزَّن نتائج تنفيذ المهام وتُحفظ - مما قد يؤثر في النتائج الإجمالية للاختبار.
مدخلات الاختبار
المدخل الأساسي للاختبارات هو قائمة من السلاسل النصية بهذا الشكل
1,192.168.1.1,2023-10-29T17:33:33.647641574
أو، بوصف أعم
{ordering-number},{ip-like-string},{timestamp}
وتُستخدم خمسة أحجام مختلفة للمدخلات:
- 100
- 1000
- 10000
- 100000
- 1000000
لم تُختر هذه الأحجام عشوائيًا: فأعتقد أن نطاقًا كهذا يمكنه إظهار مدى قابلية الحل للتوسع وقد يكشف عن عنق زجاجة في الأداء.
كما أن إعداد الاختبار مرن جدًا بشكل عام، لذا ينبغي لمن يرغب في إضافة حجم آخر أن يتمكن من ذلك دون عناء كبير.
إعداد الاختبارات
التدفق الكلاسيكي
يتكوّن اختبار التدفق الكلاسيكي من صنف واحد فقط. وتُعالَج الأحجام المختلفة على مستوى State.
public class ClassicStreamBenchmark extends BaseBenchmarkConfig {
@Benchmark
public void bench_sequential(SingleStreamState state, Blackhole bh) {
Map<String, Integer> map = state.definitions.sequentialStream(state.input);
bh.consume(map);
}
@Benchmark
public void bench_defaultParallelStream(SingleStreamState state, Blackhole bh) {
Map<String, Integer> map = state.definitions.defaultParallelStream(state.input);
bh.consume(map);
}
@Benchmark
public void bench_parallelStreamWithCustomForkJoinPool_4(SingleStreamState state, Blackhole bh) {
Map<String, Integer> map = state.definitions.parallelStreamWithCustomForkJoinPool(state.forkJoinPool_4, state.input);
bh.consume(map);
}
@Benchmark
public void bench_parallelStreamWithCustomForkJoinPool_8(SingleStreamState state, Blackhole bh) {
Map<String, Integer> map = state.definitions.parallelStreamWithCustomForkJoinPool(state.forkJoinPool_8, state.input);
bh.consume(map);
}
@Benchmark
public void bench_parallelStreamWithCustomForkJoinPool_16(SingleStreamState state, Blackhole bh) {
Map<String, Integer> map = state.definitions.parallelStreamWithCustomForkJoinPool(state.forkJoinPool_16, state.input);
bh.consume(map);
}
@Benchmark
public void bench_parallelStreamWithCustomForkJoinPool_32(SingleStreamState state, Blackhole bh) {
Map<String, Integer> map = state.definitions.parallelStreamWithCustomForkJoinPool(state.forkJoinPool_32, state.input);
bh.consume(map);
}
}
يُختبر المنطق نفسه في ستة إعدادات مختلفة:
- bench_sequential -> اختبار أساسي يستخدم تدفقًا تسلسليًا واحدًا فقط
- bench_defaultParallelStream -> اختبار يستخدم التدفق المتوازي الافتراضي في Java عبر دالة .parallelStream() في الصنف
Stream، وهو ما يعني عمليًاcommonPoolمن ForkJoinPool بدرجة توازٍ 19 (على جهازي على الأقل) - bench_parallelStreamWithCustomForkJoinPool_4 ->
ForkJoinPoolمخصص مستوى التوازي فيه 4 - bench_parallelStreamWithCustomForkJoinPool_8 ->
ForkJoinPoolمخصص مستوى التوازي فيه 8 - bench_parallelStreamWithCustomForkJoinPool_16 ->
ForkJoinPoolمخصص مستوى التوازي فيه 16 - bench_parallelStreamWithCustomForkJoinPool_32 ->
ForkJoinPoolمخصص مستوى التوازي فيه 32
بالنسبة لمنطق التدفق الكلاسيكي، فإن 6 إعدادات مختلفة مع 5 أحجام إدخال مختلفة تعطي 30 توليفة اختبار فريدة في المجموع.
Fork/Join
public class ForkJoinBenchmark extends BaseBenchmarkConfig {
@Benchmark
public void bench(ForkJoinState state, Blackhole bh) {
Map<Ip, Integer> map = new ForkJoinDefinition(state.input, state.now).compute();
bh.consume(map);
}
@Benchmark
public void bench_customForkJoinPool_4(ForkJoinState state, Blackhole bh) {
ForkJoinDefinition forkJoinDefinition = new ForkJoinDefinition(state.input, state.now);
Map<Ip, Integer> map = state.forkJoinPool_4.invoke(forkJoinDefinition);
bh.consume(map);
}
@Benchmark
public void bench_customForkJoinPool_8(ForkJoinState state, Blackhole bh) {
ForkJoinDefinition forkJoinDefinition = new ForkJoinDefinition(state.input, state.now);
Map<Ip, Integer> map = state.forkJoinPool_8.invoke(forkJoinDefinition);
bh.consume(map);
}
@Benchmark
public void bench_customForkJoinPool_16(ForkJoinState state, Blackhole bh) {
ForkJoinDefinition forkJoinDefinition = new ForkJoinDefinition(state.input, state.now);
Map<Ip, Integer> map = state.forkJoinPool_16.invoke(forkJoinDefinition);
bh.consume(map);
}
@Benchmark
public void bench_customForkJoinPool_32(ForkJoinState state, Blackhole bh) {
ForkJoinDefinition forkJoinDefinition = new ForkJoinDefinition(state.input, state.now);
Map<Ip, Integer> map = state.forkJoinPool_32.invoke(forkJoinDefinition);
bh.consume(map);
}
}
يُختبر المنطق نفسه في ستة إعدادات مختلفة:
- bench -> اختبار أساسي يستخدم تدفقًا تسلسليًا واحدًا فقط
- bench_customForkJoinPool_4 -> ForkJoinPool مخصص مستوى التوازي فيه 4
- bench_customForkJoinPool_8 -> ForkJoinPool مخصص مستوى التوازي فيه 8
- bench_customForkJoinPool_16 -> ForkJoinPool مخصص مستوى التوازي فيه 16
- bench_customForkJoinPool_32 -> ForkJoinPool مخصص مستوى التوازي فيه 32
بالنسبة لمنطق التدفق الكلاسيكي، فإن 5 إعدادات مختلفة مع 5 أحجام إدخال مختلفة تعطي 25 توليفة اختبار فريدة في المجموع.
وإضافة إلى ذلك، تستخدم الحالتان مفهوم JMH Blackhole “لخداع” تحسين الشيفرة الميتة في المصرّف. يمكنكم قراءة المزيد عن Blackholes ومتى تُستخدم هنا.
بيئة الاختبار
الجهاز 1
أجرينا الاختبارات على جهاز Dell XPS الخاص بي، ومواصفاته:
نظام التشغيل: Ubuntu 20.04.6 LTS
المعالج: i9-12900HK × 20
الذاكرة: 64 GB
JVM
openjdk version “21” 2023-09-19
OpenJDK Runtime Environment (build 21+35-2513)
OpenJDK 64-Bit Server VM (build 21+35-2513, mixed mode, sharing)
الجهاز 2
أجرينا الاختبارات على جهاز Lenovo Y700 الخاص بي، ومواصفاته:
نظام التشغيل: Ubuntu 20.04.6 LTS
المعالج: i7-6700HQ × 8
الذاكرة: 32 GB
JVM
openjdk version “21” 2023-09-19
OpenJDK Runtime Environment (build 21+35-2513)
OpenJDK 64-Bit Server VM (build 21+35-2513, mixed mode, sharing)
على الجهازين أُغلقت جميع التطبيقات الثانوية أو غير المهمة. وقد سعيت إلى إبقاء نظام التشغيل نظيفًا قدر استطاعتي حتى لا أُدخل أي عبء أداء غير مرغوب فيه. ومع ذلك، قد يختلف الأداء الإجمالي على خادم Ubuntu مجرّد أو عند التشغيل داخل حاوية.
تقرير الاختبار
تُحفظ نتائج الاختبارات في ملفات .csv، موجودة في مستودع GitHub ضمن مجلد reports. ولتسهيل تنزيل التقارير، هناك أيضًا ملف .zip منفصل باسم reports.zip يحتوي جميع ملفات بيانات .csv.
تُنظَّم مجلدات التقارير بحسب الحجم، إضافة إلى ثلاثة تقارير خاصة تغطي جميع أحجام الإدخال:
- report_classic - كل أحجام الإدخال للتدفق الكلاسيكي
- report_forkjoin - كل أحجام الإدخال لتدفق fork/join
- report_whole - كل أحجام الإدخال لكل من التدفقين الكلاسيكي وfork/join
يحتوي كل مجلد من مجلدات التقارير أعلاه على 3 ملفات منفصلة:
- averagetime.csv - نتائج اختبارات وضع متوسط الزمن
- throughput.csv - نتائج اختبارات وضع الإنتاجية
- total.csv - نتائج الوضعين مجتمعةً
وتأتي هذه التقارير بصيغتين - يتشارك averagetime.csv وthroughput.csv صيغة واحدة، بينما يستخدم total.csv صيغة أخرى. لنسمِّهما صيغة الأوضاع وصيغة الإجمالي.
يحتوي تقرير الأوضاع على ثمانية أعمدة:
- Label - اسم الاختبار
- Input Size - حجم مدخل الاختبار
- Threads - عدد الخيوط التي استخدمها الاختبار، من المجموعة 1,4,7,8,16,19,32
- Mode - وضع الاختبار، إما متوسط الزمن أو الإنتاجية
- Cnt - عدد دورات الاختبار، ويجب أن يكون دائمًا 20
- Score - نتيجة الاختبار الفعلية
- Score Mean Error - خطأ القياس في الاختبار
- Units - وحدات الاختبار، إما ms/op (لمتوسط الزمن) أو ops/ms (للإنتاجية**)**
ويحتوي تقرير الإجمالي على 10 أعمدة:
- Label - اسم الاختبار
- Input Size - حجم مدخل الاختبار
- Threads - عدد الخيوط التي استخدمها الاختبار، من المجموعة 1,4,7,8,16,19,32
- Cnt - عدد دورات الاختبار، ويجب أن يكون دائمًا 20
- AvgTimeScore - نتيجة الاختبار الفعلية في وضع متوسط الزمن
- AvgTimeMeanError - خطأ القياس في الاختبار في وضع متوسط الزمن
- AvgUnits - وحدات الاختبار في وضع متوسط الزمن، بـ ms/op
- ThroughputScore - نتيجة الاختبار الفعلية
- ThroughputMeanError - خطأ القياس في الاختبار في وضع الإنتاجية
- ThroughputUnits - وحدات الاختبار في وضع الإنتاجية، بـ ops/ms
تحليل النتائج
الافتراضات
خط الأساس
النتائج والاستنتاجات العامة التي أعرضها مبنية على الحجم 10000 – أي أنني أستخدم ملفات .csv من مجلد report_10000.
اخترت حجم البيانات هذا تحديدًا لسببين رئيسيين.
- زمن التنفيذ طويل بما يكفي لإظهار أي فروق بين الإعدادات.
- في رأيي، حجما البيانات 100 و1000 صغيران جدًا بحيث لا يكشفان بعض اختناقات الأداء
ولهذا السبب أعتقد أن التحليل المفصّل لحجم البيانات هذا سيكون الأكثر قيمة.
وبطبيعة الحال، ستحصل الأحجام الأخرى على نظرة عامة على نتائجها أيضًا، وإن لم تكن مفصّلة مثل هذا الحجم، إلا إذا صادفت حالات شاذة – مقارنةً بسلوك الحجم 10000.
كلمة عن نهج Fork/Join الأصلي
بالنظر إلى الشيفرة التي تُختبر حاليًا، فإن اختبارات Fork/Join تحمل بعض العبء على الأداء.
ولأن منطق اختبار fork join يعتمد بشدة على تقسيم مجموعة بيانات الإدخال، فلا بد في مرحلة ما من دمج جميع النتائج الجزئية في مخرج متماسك واحد. وهذه الخطوة غائبة عن الاختبارات العادية، لذا من الضروري فهم تأثيرها في الأداء الإجمالي فهمًا صحيحًا.
يرجى وضع ذلك في الاعتبار.
التحليل
الجهاز 1 (20 نواة)
كما هو مبيّن أعلاه، على الجهاز 1 تأتي أفضل نتيجة إجمالية لمدخل من 10 آلاف عنصر من نسخ defaultParallelStream.
ومن بين الاختبارات المبنية على ClassicStream، يحقق bench_defaultParallelStream أفضل نتيجة بفارق كبير. ويبقى في المركز الأول حتى بعد احتساب خطأ القياس المحتمل.
أما إعدادات ForkJoinPool بدرجة توازٍ 32 و16 فتعطي نتائج أسوأ. من جهة، هذا مفاجئ - فمع درجة توازٍ 32 كنت أتوقع نتيجة أفضل من المجمّع الافتراضي (درجة توازٍ 19). ومن جهة أخرى، ليس كذلك - فدرجة التوازي 16 تؤدي أسوأ من درجتي التوازي 19 و32 معًا.
وبما أن الجهاز 1 يحتوي 20 خيط معالج، فإن درجة التوازي 32 ليست عالية بما يكفي لإظهار هبوط الأداء الناتج عن كثرة الخيوط. لكنك سترى سلوكًا كهذا على الجهاز 2. وأخمّن أن إعادة إنتاجه على الجهاز 1 تتطلب ضبط درجة التوازي على 64 أو أكثر.
ومن المثير للاهتمام أن bench_defaultParallelStream لا يبدو أنه يبقى في الصدارة مع أحجام الإدخال الأكبر، 100 ألف ومليون. فهناك يأتي أفضل أداء من bench_parallelStreamWithCustomForkJoinPool_16، وهو ما قد يوحي بأن درجة توازٍ أدنى بقدر معقول قد تكون خيارًا جيدًا في النهاية.
إن التطبيق المبني على Fork/Join أبطأ بوضوح من تطبيق التدفق المتوازي الافتراضي، إذ يؤدي أسوأ بنحو 10 %. ويظهر النمط نفسه في الأحجام الأخرى أيضًا. وهذا يؤكد افتراضي السابق بأن دمج القطع الأصغر من مجموعة البيانات المقسّمة له كلفة ملحوظة.
وكما هو متوقع، يسجّل النهج أحادي الخيط أسوأ نتيجة، إذ يكون أبطأ بنحو 5 مرات من أفضل نتيجة. وهذا متوقع، فأنا أعامل اختبار الخيط الواحد كنوع من خط الأساس. أريد أن أرى مقدار التحسن الممكن في زمن تنفيذه، ومتوسط زمن تنفيذ أفضل بخمس مرات في أفضل الأحوال يبدو نتيجة جيدة.
متوسط خطأ النتيجة صغير للغاية. وحتى في أسوأ حالاته (أعلى خطأ)، يبقى ضمن 1,5% من النتيجة المقابلة - وهي نتيجة ClassicStreamBenchmark.bench_parallelStreamWithCustomForkJoinPool_4.
وفي الحالات المتبقية يتراوح بين 0,1 % و0,7 % من النتيجة الكلية.
أما للأحجام التي تتجاوز 10 آلاف، فيبدو أن ترتيب النتائج لا يتغير.
الجهاز 2 (8 أنوية)
تمامًا كما في الجهاز 1، تذهب أعلى نتيجة مجددًا إلى bench_defaultParallelStream. ومجددًا يبقى في المركز الأول حتى مع احتساب خطأ القياس المحتمل. لا شيء لافت بشكل خاص.
أما اللافت فهو أن ترتيب المراكز الثلاثة الأولى على الجهاز 2 يتغير بشكل كبير مع أحجام الإدخال الأكبر. فمع مدخلات من 100 إلى 10 000، يكون السلوك متشابهًا إلى حد كبير، إذ يحتل bench_defaultParallelStream المركز الأول ويليه عن قرب bench_parallelStreamWithCustomForkJoinPool_8.
أما مع مدخلات 100 000 و1 000 000، فعلى العكس، يحتل bench_parallelStreamWithCustomForkJoinPool_8 المركز الأول، ويليه مباشرة bench_parallelStreamWithCustomForkJoinPool_32. وفي الوقت نفسه يهبط bench_defaultParallelStream إلى المركزين الرابع والثالث
وجانب آخر مثير للاهتمام في الجهاز 2 هو أنه مع أحجام الإدخال الأصغر تقع درجة التوازي 32 بعيدًا عن القمة. وقد يعود هذا الهبوط في الأداء إلى كثرة الخيوط قياسًا إلى خيوط المعالج الثمانية التي يملكها الجهاز في المجموع.
ومع ذلك، ففي مدخلات 100 000 و1 000 000 يحتل ForkJoinPool بدرجة توازٍ 32 المركز الثاني، وهو ما قد يوحي بأن كثرة الخيوط ليست مشكلة على فترات زمنية أطول.
وقد حُذفت هنا بضعة جوانب أخرى تطابق سلوك الجهاز 1 عن كثب، ونتناولها أدناه.
نقاط مشتركة
هناك بعض الملاحظات التي تصدق على الجهازين:
- اختباراتي المبنية على ForkJoinNative (“الساذج”) تعطي نتائج أسوأ بوضوح، بنحو 10% على الجهازين، من نسخ التدفق المتوازي الافتراضي أو حتى تلك التي تستخدم customForkJoinPool.
وبطبيعة الحال، جزء من السبب أنها لم تُحسَّن إطلاقًا، ومن المرجح أن هناك مكاسب أداء سهلة يمكن تحقيقها. ولهذا أنصح بشدة بالتعرف جيدًا على إطار Fork/Join قبل نقل تطبيقاته إلى الإنتاج. - الفارق الزمني بين المركز الأول والثالث ضئيل – أقل من ميلي ثانية. وقد يجعل هذا من الصعب إعادة إنتاج هذه الاختبارات بشكل ذي معنى. ومع فارق صغير كهذا، يمكن أن يختلف توزيع النتائج بسهولة من تشغيل اختبار إلى آخر.
- متوسط خطأ النتائج (mean Error) ضئيل أيضًا، بحد أقصى 2% من النتيجة الكلية في أسوأ الحالات – وهو عادة أقل من 1%. وقد يشير خطأ منخفض كهذا إلى أمرين. أولًا، أن الاختبارات موثوقة، لأن النتائج تتجمع حول نقطة معيّنة؛ ولو وُجدت حالات شاذة لكان الخطأ أكبر. وثانيًا، أن JMH يقوم بعمل جيد في أخذ القياسات.
- لا يعطي وضعا الإنتاجية ومتوسط الزمن نتائج مختلفة جوهريًا. فالاختبار الذي أبلى بلاءً حسنًا في وضع متوسط الزمن أبلى بلاءً حسنًا في وضع الإنتاجية أيضًا.
هذه هي جميع الفروق وأوجه التشابه التي لاحظتها في ملفات التقارير. وإذا لفت انتباهكم أي شيء آخر مثير للاهتمام، فلا تترددوا في ذكره في التعليقات أدناه.
الخلاصة
قبل أن نفترق اليوم، هناك أمر آخر مهم جدًا أريد الإشارة إليه.
JAVA ليست بطيئة
إن معالجة قائمة من مليون عنصر، مع كل عبء JMH المحتمل وعلى خيط واحد، تستغرق 560 ميلي ثانية (الجهاز 1) و1142 ميلي ثانية (الجهاز 2). ولم تُطبَّق أي تحسينات خاصة أو حيل – مجرد JVM افتراضية عادية.
وكان أفضل زمن إجمالي لمعالجة مليون عنصر على الجهاز 1 هو 88 ميلي ثانية، حققه ClassicStreamBenchmark.bench_parallelStreamWithCustomForkJoinPool_16. وعلى الجهاز 2 كان 321 ميلي ثانية، حققه ClassicStreamBenchmark.bench_parallelStreamWithCustomForkJoinPool_8.
قد لا تضاهي أيٌّ من النتيجتين الحلول المبنية على C/C++، لكنني أرى أن البساطة النسبية وقوة التعبير في هذا النهج تجعلانه جذابًا جدًا.
وإجمالًا، فهو مكمّل لطيف جدًا لتحدي المليار صف (one billion rows challenge) في Java.
يمكنكم تشغيل الاختبارات نفسها لمقارنة نتائجي بسلوكها على أجهزتكم.
كما أنه لتسهيل تنزيل التقارير (reposts)، هناك ملف .zip منفصل باسم reports.zip يحتوي جميع ملفات بيانات .csv.
وتذكّروا: Java ليست بطيئة.
شكرًا على وقتكم.