> ## Content Index
> Fetch the complete content index at: https://arabroot.io/llms.txt
> Use this file to discover other available public pages before exploring further.

# CISC أم RISC: ما الفرق الحقيقي بين x86 وARM وRISC-V؟
- URL: https://arabroot.io/articles/cisc-ام-risc-الفرق-الحقيقي-بين-x86-و-arm-و-risc-v/
- Published: 2026-11-16T18:39:49.000Z
- Updated: 2026-11-16T21:59:32.000Z
- Description: نقيس حجم الكود وعدد التعليمات المنفذة لنفس البرامج على x86-64 وARM64 وRISC-V، ونرى ما بقي من نقاش CISC وRISC وما لم يعد صحيحاً.
- Author: فريق عرب رووت
- Tags: الأدلة التقنية, أساسيات الحاسب والبرمجة, لينكس والسيرفرات

عندما تقرأ عن سيرفرات ARM في السحابة أو عن أجهزة Mac الحديثة، فغالباً سوف تجد جملة مثل «معالجات ARM أوفر في الطاقة لأنها RISC، ومعالجات x86 تستهلك أكثر لأنها CISC قديمة ومعقدة»، وقد تسمع العكس من شخص آخر: «لا فرق اليوم، فمعالجات x86 من الداخل RISC أصلاً». والجملتان تتكرران في النقاشات وفي مقارنات الشراء حتى صارتا كأنهما حقائق، مع أن كل واحدة منهما فيها جزء صحيح وجزء غير دقيق، والطريقة الوحيدة لتعرف أيهما هو أن تنظر إلى الكود الذي ينتجه المترجم فعلاً وتعده وتقيسه.

وهذا المقال يكمل مقال معمارية المعالج ISA الذي سبقه في نفس المرحلة، حيث عرفنا أن ال ISA عقد بين البرنامج والشريحة، وقرأنا نفس الدالة مترجمة لـ x86-64 وARM64 وRISC-V. أما هنا فسوف نأخذ نفس الأدوات إلى برامج أكبر، ونقيس الأشياء التي يقال إنها تفرق بين الفلسفتين: حجم الكود، وطول التعليمة، وعدد التعليمات التي ينفذها المعالج لنفس العمل، وكم عملية داخلية تصبح كل تعليمة في معالج Intel حقيقي.

[![](https://arabroot.io/content/images/2026/11/isa-explained-cover-cover.webp)دليلمعمارية المعالج ISA: لماذا لا يعمل برنامج x86 على ARM؟نترجم نفس برنامج C لثلاث معماريات ونقرأ تعليماته سطراً سطراً، لنفهم ما الذي يجعل الملف التنفيذي يعمل على معالج ويرفضه معالج آخر.](https://arabroot.io/articles/%D9%85%D8%B9%D9%85%D8%A7%D8%B1%D9%8A%D8%A9-%D8%A7%D9%84%D9%85%D8%B9%D8%A7%D9%84%D8%AC-isa-%D9%88%D9%84%D9%85%D8%A7%D8%B0%D8%A7-%D9%84%D8%A7-%D9%8A%D8%B9%D9%85%D9%84-%D8%A8%D8%B1%D9%86%D8%A7%D9%85%D8%AC-x86-%D8%B9%D9%84%D9%89-arm/)[![](https://arabroot.io/content/images/2026/10/cpu-internals-cover-cover.webp)دليلكيف يعمل المعالج CPU من الداخل ولماذا يهمك ذلكنتابع تعليمة واحدة داخل نواة المعالج، ونرى لماذا يصبح نفس الكود أبطأ بعشر مرات عندما تغير ترتيب المرور على البيانات.](https://arabroot.io/articles/%D9%83%D9%8A%D9%81-%D9%8A%D8%B9%D9%85%D9%84-%D8%A7%D9%84%D9%85%D8%B9%D8%A7%D9%84%D8%AC-cpu-%D9%85%D9%86-%D8%A7%D9%84%D8%AF%D8%A7%D8%AE%D9%84/)

وسوف نناقش في هذا المقال ما يلي:

- من أين جاءت الكلمتان CISC وRISC، وما المشكلة التي كانت كل فلسفة تحلها في السبعينات والثمانينات.
- الفروق الكلاسيكية بينهما على مثال حقيقي: طول التعليمة، والذاكرة داخل الحساب، والمسجلات، والأعلام.
- ما الذي تغير منذ معالج Pentium Pro: العمليات الصغيرة Micro-ops، والمفكك Decoder، ودمج التعليمات Macro-fusion.
- مختبر أول: حجم كود الآلة لنواة لغة Lua على المعماريات الثلاث، مع التعليمات المضغوطة في RISC-V ودونها.
- مختبر ثان: كم بايتاً طول التعليمة الواحدة فعلاً، بتوزيع حقيقي لعشرات الآلاف من التعليمات.
- مختبر ثالث: كم تعليمة ينفذها كل معالج لنفس العمل، بالعد عبر المحاكي QEMU، ثم التحقق بعدادات العتاد في الأداة `perf` على معالج Intel حقيقي، وكم عملية صغيرة أصبحت هذه التعليمات.
- أين ما زال الفرق مهماً اليوم، وأين لم يعد كذلك، وكيف اقتربت x86 من RISC واقتربت ARM من CISC.
- الأخطاء الشائعة في هذا النقاش، وجدول قرار لما يهمك عند اختيار سيرفر أو جهاز.

## من أين جاءت الكلمتان CISC وRISC؟

في السبعينات كانت الذاكرة غالية جداً وبطيئة، والمترجمات Compilers ضعيفة، وكثير من البرامج يكتب بلغة التجميع Assembly مباشرة، فكان من المنطقي أن يصمم المعالج بتعليمات غنية تفعل الكثير في خطوة واحدة: تعليمة تقرأ من الذاكرة وتحسب وتكتب النتيجة في الذاكرة، وتعليمة تنسخ نصاً كاملاً، وطرق عنونة كثيرة تجعل كتابة الكود يدوياً أسهل. وبهذا يكون البرنامج أقصر ويأخذ ذاكرة أقل، وينفذ المعالج كل تعليمة معقدة عبر برنامج صغير داخلي اسمه ال Microcode. ومعالج Intel 8086 الذي صدر في يونيو 1978 كان كما تذكر [صفحة تاريخ Intel](https://www.intel.com/content/www/us/en/history/virtual-vault/articles/the-8086-and-the-ibm-pc.html?ref=arabroot.io) أول معالج للشركة فيه Microcode، وهو جد كل معالجات x86 اليوم.

وفي نفس الفترة لاحظ فريق في IBM بقيادة John Cocke شيئاً مختلفاً: المترجمات لا تستخدم أغلب التعليمات المعقدة أصلاً، والتعليمات القليلة التي تستخدمها كثيراً يمكن أن تنفذ أسرع بكثير إذا كانت بسيطة، لأن المعالج البسيط يمكن تقسيمه إلى مراحل تعمل معاً في خط تنفيذ Pipeline. ونتج عن ذلك نموذج IBM 801 في 1980، كما تذكر [صفحة تاريخ IBM عن RISC](https://www.ibm.com/history/risc?ref=arabroot.io)، والتي تنقل أيضاً مبدأ الفريق: لا تضف أي تعقيد إلى الآلة إلا إذا دفع ثمنه بكثرة استخدامه. ثم جاءت الكلمة نفسها من جامعة Berkeley على يد David Patterson وCarlo Séquin، وفي Stanford قاد John Hennessy مشروعاً مشابهاً أصبح MIPS، ومن هذه الفكرة خرجت معالجات ARM وPOWER وSPARC، وأخيراً RISC-V التي بدأت في Berkeley في مايو 2010 كما تذكر [صفحة RISC-V International](https://riscv.org/about/?ref=arabroot.io).

والصورة التالية تلخص هذا التاريخ، وتنتهي بنتيجة دراسة سوف نعود إليها في آخر المقال:

![عمودان: عمود أزرق للتعليمات الغنية CISC فيه ثلاثة أحداث هي Intel 8086 في 1978 أول معالج من Intel فيه Microcode، و80386 في 1985 بحجم 32 بت، وPentium Pro في 1995 يترجم التعليمات إلى Micro-ops، وعمود أخضر للتعليمات البسيطة RISC فيه IBM 801 في 1980، وPatterson وHennessy في الثمانينات ثم ARM وPOWER، وRISC-V في 2010، وفي الأسفل شريط داكن لسنة 2013 يذكر دراسة جامعة Wisconsin التي خلصت إلى أن نوع ال ISA لا يحدد الأداء ولا الطاقة](https://arabroot.io/content/images/2026/11/cisc-vs-risc-01-origins.webp)

فلسفتان ولدتا لحل مشاكل السبعينات، ثم التقتا داخل نفس الشريحة

ولاحظ أن الكلمتين وصف لفلسفة تصميم ال ISA، أي العقد، وليستا وصفاً لطريقة بناء الشريحة من الداخل، وهذا التفريق هو مفتاح فهم النقاش كله اليوم، لأن ما حدث بعد التسعينات أن شرائح x86 صارت تنفذ عقدها القديم بمحرك داخلي يشبه محركات RISC.

## الفروق الكلاسيكية على مثال حقيقي

الكتب تذكر عادة قائمة من الفروق، وأسهل طريقة لفهمها أن نراها على نفس الحلقة. والحلقة التالية من الدالة `total` التي ترجمناها في المقال السابق، وهي تجمع مصفوفة من الأسعار، والبايتات في الصورة من مخرج `objdump` كما هي:

![ثلاثة أعمدة لنفس الحلقة: عمود x86-64 فيه أربع تعليمات بأطوال 3 و4 و3 و2 بايتات أولها add (%rdi),%rcx التي تقرأ من الذاكرة وتجمع، والمجموع 12 بايتاً، وعمود ARM64 فيه أربع تعليمات بطول 4 بايتات أولها ldr x1, [x0], #8 والمجموع 16 بايتاً، وعمود RISC-V فيه ثلاث تعليمات ببايتين وتعليمة bne بأربعة بايتات والمجموع 10 بايتات، وتحتها ثلاث ملاحظات عن الذاكرة داخل الحساب والأعلام والكثافة](https://arabroot.io/content/images/2026/11/cisc-vs-risc-02-same-loop.webp)

نفس الحلقة: أربع تعليمات في المعماريات الثلاث، والفرق في التفاصيل

ومن هذا المثال نستطيع أن نكتب الفروق الكلاسيكية واحداً واحداً:

- **طول التعليمة:** في x86-64 من بايت واحد إلى 15 بايتاً كما يذكر [دليل Intel للمطورين](https://www.intel.com/content/www/us/en/developer/articles/technical/intel-sdm.html?ref=arabroot.io)، وفي ARM64 أربعة بايتات دائماً، وفي RISC-V أربعة بايتات أو بايتان مع الامتداد C. والطول الثابت كان من أهم أفكار RISC، لأنه يجعل الجلب والفك بسيطين.
- **الذاكرة داخل الحساب:** في x86-64 تستطيع التعليمة `add (%rdi),%rcx` أن تقرأ السعر من الذاكرة وتجمعه في خطوة، أما في ARM64 وRISC-V فالتعليمات الحسابية لا تلمس الذاكرة أبداً، والقراءة والكتابة لهما تعليمات خاصة، وهذا ما يسمى معمارية التحميل والتخزين Load-Store.
- **عدد المسجلات:** 16 مسجلاً عاماً في x86-64، و31 في ARM64، و32 في RISC-V. والمسجلات الكثيرة فكرة RISC أيضاً، لأن البيانات التي لا تجد مسجلاً تذهب إلى الذاكرة ثم تعود منها.
- **معاملان أو ثلاثة:** أغلب تعليمات x86-64 تكتب النتيجة فوق أحد المصدرين، مثل `add $0x8,%rdi`، بينما في ARM64 وRISC-V تحدد مسجلاً ثالثاً للنتيجة، مثل `add x3, x3, x1`، فلا تحتاج نسخة احتياطية من قيمة تريدها بعد العملية.
- **الأعلام Flags:** في x86-64 وARM64 تكتب `cmp` نتيجة المقارنة في سجل خاص للأعلام، ثم تقرؤه تعليمة القفز، أما RISC-V فلا تملك أعلاماً أصلاً، وتعليمة `bne` تقارن وتقفز معاً.
- **العنونة:** x86-64 تقدم صيغة غنية مثل «أساس زائد مؤشر مضروب في 8 زائد إزاحة»، وARM64 تقدم صيغاً أقل ولكن فيها حيل مثل زيادة المؤشر بعد القراءة، وRISC-V تقدم صيغة واحدة تقريباً: مسجل زائد إزاحة.

ولكن لاحظ نتيجتين في الصورة لا تتفقان مع الكلام الشائع: الحلقة أربع تعليمات في المعماريات الثلاث، فالفلسفة البسيطة لم تحتج تعليمات أكثر هنا، وأقصر كود ليس كود x86-64 الذي يوصف عادة بأنه الأكثر كثافة، وإنما كود RISC-V بعشرة بايتات. وهذه أول إشارة إلى أن الصورة الحقيقية أعقد من الجدول، ولذلك سوف نقيس على برنامج أكبر بعد قليل.

## ما الذي تغير؟ العمليات الصغيرة Micro-ops

في 1995 أطلقت Intel معالج Pentium Pro، وهو أول معالج من معمارية P6 الدقيقة، وكانت فيه فكرة غيرت النقاش: المعالج لا ينفذ تعليمات x86 كما هي، وإنما يفك كل تعليمة إلى عملية صغيرة أو أكثر تسمى Micro-ops، كل منها بسيط ومنتظم مثل تعليمات RISC، ثم ينفذ هذه العمليات بمحرك خارج الترتيب Out-of-Order. فالتعليمة `add (%rdi),%rcx` مثلاً تصبح داخلياً عملية تحميل وعملية جمع، تماماً كما تكتبها ARM64 بتعليمتين. والصورة التالية فيها صورة حقيقية لمعالج Pentium Pro بعد نزع غطائه، وبجانبها شريحة Apple M1 التي تتكلم ARM64:

![صورتان حقيقيتان: على اليمين معالج Pentium Pro مربع بدبابيس ذهبية كثيرة وقد نزع غطاؤه فظهرت شريحتان ذهبيتان متجاورتان، الشريحة اليمنى هي المعالج واليسرى ذاكرة L2، وعلى اليسار شريحة Apple M1 الفضية على لوحة Mac mini وعليها شعار Apple ورقمها، وبجانبها شريحتا ذاكرة داكنتان](https://arabroot.io/content/images/2026/11/cisc-vs-risc-07-pentium-pro-m1.webp)

على اليمين Pentium Pro مفتوحاً: المعالج على اليمين وذاكرة L2 على اليسار، وعلى اليسار شريحة Apple M1 على لوحة Mac mini. الصور من Wikimedia Commons: [Pentium Pro](https://commons.wikimedia.org/wiki/File:Intel%5FPentium%5FPro%5FCabrio%5F%286556646555%29.jpg?ref=arabroot.io) لـ Dennis van Zuijlekom بترخيص CC BY-SA 2.0، و[Apple M1](https://commons.wikimedia.org/wiki/File:Mac%5FMini%5FM1%5Fchip.jpg?ref=arabroot.io) لـ Sonic8400 بترخيص CC BY-SA 4.0

ولتقريب الفكرة تخيل مطعماً يستقبل الطلبات بلغة قديمة فيها أطباق مركبة كثيرة، مثل «الوجبة رقم 7»، بينما المطبخ نفسه لا يعرف إلا خطوات بسيطة: اقل، اشو، ضع في الصحن. فالموظف عند الباب يترجم كل طلب مركب إلى خطوات بسيطة، والمطبخ ينفذ الخطوات من كل الطلبات بالترتيب الذي يناسبه. والزبون يرى نفس اللغة القديمة، والمطبخ حديث تماماً، وكلفة النظام كله في الموظف الذي يترجم. أما التعليمات النادرة المعقدة جداً، مثل نسخ نص كامل بالتعليمة `rep movsb`، فلا يترجمها المفكك مباشرة، وإنما يشغل لها برنامجاً صغيراً من ال Microcode ينتج سلسلة طويلة من العمليات، تماماً كوصفة مكتوبة يرجع إليها الموظف للطلبات النادرة.

ومنذ ذلك الوقت صار الفرق بين الفلسفتين في المعالجات الكبيرة محصوراً في مقدمة المعالج Front End، أي الجزء الذي يجلب التعليمات ويفكها، أما المحرك الذي ينفذ العمليات الصغيرة ويعيد ترتيبها ويتوقع التفرعات فمتشابه في الفكرة بين x86-64 وARM64\. والصورة التالية تبين أين يقع الفرق، ومعها أرقام حقيقية من جهاز التجارب سوف نشرح كيف قسناها في [جزء العمليات الصغيرة](#lab-uops):

![مساران متوازيان بأربع مراحل: مسار x86-64 يبدأ بمرحلة محاطة بخط أحمر متقطع هي تحديد أين تنتهي التعليمة لأن طولها من 1 إلى 15 بايتاً، ثم الفك إلى عمليات صغيرة مع Microcode للمعقدة، ثم ذاكرة العمليات uop Cache، ثم محرك التنفيذ، ومسار ARM64 يبدأ بحدود معروفة لأن كل تعليمة 4 بايتات، ثم الفك، ثم الدمج والتقسيم، ثم نفس محرك التنفيذ، وتحتهما ثلاث بطاقات بأرقام من perf: حلقة CRC من 3,374,312 تعليمة إلى 3,022,405 عملية، والترتيب qsort صدرت فيه 7,136,438 عملية واكتمل 6,044,600، وحلقة الجمع 753,013 تعليمة و724,306 عملية](https://arabroot.io/content/images/2026/11/cisc-vs-risc-03-front-end.webp)

الفرق في المقدمة، والمحرك متشابه

في الصورة أعلاه لاحظ التالي:

- **المرحلة الأولى هي الأصعب في x86-64:** المعالج الحديث يريد أن يفك عدة تعليمات في كل نبضة، ولكن مع الطول المتغير لا يعرف أين تبدأ التعليمة الثانية حتى يعرف طول الأولى، فيحتاج منطقاً إضافياً يحدد الحدود قبل الفك. أما في ARM64 فالتعليمة الثامنة تبدأ دائماً بعد 28 بايتاً من الأولى، والمفككات تعمل معاً دون انتظار.
- **ذاكرة العمليات uop Cache:** لتخفيف كلفة الفك تحفظ معالجات Intel وAMD الحديثة نتيجة الفك للكود المتكرر، كما يشرح [دليل Intel لتحسين الأداء](https://www.intel.com/content/www/us/en/developer/articles/technical/intel64-and-ia32-architectures-optimization.html?ref=arabroot.io)، فالحلقة التي تدور ملايين المرات لا تفك إلا مرة واحدة تقريباً.
- **الدمج والتقسيم في الاتجاهين:** x86-64 يقسم التعليمة المعقدة إلى عدة عمليات، ولكنه أيضاً يدمج تعليمتين في عملية واحدة، مثل المقارنة أو الطرح مع القفز الذي يليها، وهذا ما يسمى Macro-fusion. ومعالجات ARM الكبيرة تفعل أشياء مشابهة، فبعض تعليماتها مثل `ldp` التي تحمل مسجلين تقسم داخلياً.

وقد يتساءل البعض: إذا كان المعالج يترجم x86 إلى عمليات تشبه RISC، فهل صارت معالجات x86 «RISC من الداخل» كما يقال؟ والإجابة أن الجملة صحيحة في نصفها: المحرك الداخلي منتظم مثل RISC، ولكن العقد الخارجي ما زال x86 بكل ما فيه، والمعالج يدفع ثمن ترجمته في كل نبضة، والسؤال الحقيقي هو كم هذا الثمن، وهذا ما سوف نحاول أن نقيسه.

## تجهيز المختبر Lab Setup

نستخدم نفس ال Image التي بنيناها في مقال معمارية المعالج ISA، وفيها المترجمات الثلاثة وأدوات `objdump` والمحاكي QEMU في وضع المستخدم، فإذا لم تبنها بعد فهذا ملفها:

```dockerfile
FROM debian:trixie-slim
RUN apt-get update && apt-get install -y --no-install-recommends \
      gcc libc6-dev gcc-aarch64-linux-gnu libc6-dev-arm64-cross gcc-riscv64-linux-gnu libc6-dev-riscv64-cross \
      binutils qemu-user file cpuid nasm qemu-system-x86 qemu-system-gui- \
    && rm -rf /var/lib/apt/lists/*
WORKDIR /lab
```

```bash
mkdir risc-lab && cd risc-lab      # put the Dockerfile and the lab scripts here
docker build -t cs1-isa:1 .
curl -sO https://www.lua.org/ftp/lua-5.4.9.tar.gz
sha256sum lua-5.4.9.tar.gz
```

والملف `lua-5.4.9.tar.gz` هو الكود المصدري للغة [Lua](https://www.lua.org/?ref=arabroot.io) من موقعها الرسمي، واخترناها لأنها برنامج حقيقي مكتوب بلغة C فيه قرابة 30 ألف سطر، دون أي اعتماد على مكتبات خارجية، وتترجم بنفس الشكل على المعماريات الثلاث. والبصمة التي حصلنا عليها كما يلي، فقارنها ببصمتك قبل أن تكمل:

```text
2335b6c582a52654f94612bf10d2f4672805d05329aa6568b1d8cd9e5c6fb8e6  lua-5.4.9.tar.gz
```

## المختبر الأول: حجم كود الآلة لنفس البرنامج

أشهر حجة قديمة لـ CISC هي كثافة الكود Code Density: التعليمات الغنية والأطوال المتغيرة تجعل البرنامج أقصر، فيأخذ ذاكرة أقل ويدخل أكثر منه في ذاكرة التعليمات L1i. ولنختبر ذلك نترجم ملفات نواة Lua، وهي 32 ملفاً بعد استبعاد البرنامجين `lua.c` و`luac.c`، لكل معمارية، ثم نجمع حجم الأقسام `.text` فقط، وهي التي تحتوي كود الآلة، بالأداة [size](https://man7.org/linux/man-pages/man1/size.1.html?ref=arabroot.io). ونترجم مرتين: مرة بالخيار `-O2` الذي يفضل السرعة، ومرة بالخيار `-Os` الذي يفضل الحجم، ونترجم RISC-V مرتين في كل منهما: مع الامتداد C للتعليمات المضغوطة (`rv64gc`) ودونه (`rv64g`)، كما يسمح [توثيق خيارات RISC-V في GCC](https://gcc.gnu.org/onlinedocs/gcc/RISC-V-Options.html?ref=arabroot.io). والسكربت كما يلي:

```bash
#!/bin/bash
# codesize.sh: compile Lua's core for each ISA and add up the .text sections (machine code only)
set -e
tar xzf lua-5.4.9.tar.gz
cd lua-5.4.9/src
SRC=$(ls *.c | grep -v -E '^(lua|luac)\.c$')
build() {   # $1 = label, $2 = compiler, $3.. = flags
  label=$1; cc=$2; shift 2
  rm -rf /tmp/o && mkdir /tmp/o
  for f in $SRC; do $cc "$@" -DLUA_USE_LINUX -c $f -o /tmp/o/${f%.c}.o; done
  text=0; for o in /tmp/o/*.o; do t=$(size -A $o | awk '$1 ~ /^\.text/ {s+=$2} END {print s+0}'); text=$((text+t)); done
  printf '%-28s %8d bytes of .text in %d object files\n' "$label" $text $(ls /tmp/o/*.o | wc -l)
}
for opt in -O2 -Os; do
  build "x86-64 $opt"            gcc                    $opt
  build "aarch64 $opt"           aarch64-linux-gnu-gcc  $opt
  build "riscv64 rv64gc $opt"    riscv64-linux-gnu-gcc  $opt -march=rv64gc -mabi=lp64d
  build "riscv64 rv64g (no C) $opt" riscv64-linux-gnu-gcc $opt -march=rv64g -mabi=lp64d
done
```

```bash
docker run --rm --name cs1-lua -v "$PWD:/lab" cs1-isa:1 bash -c 'cp -r /lab /w && cd /w && bash codesize.sh'
```

ولاحظ أن الأمر ينسخ المجلد داخل ال Container قبل الترجمة، والسبب أن الترجمة على مجلد مشترك مع Windows عبر Docker Desktop بطيئة جداً، فكل ملف صغير يمر عبر طبقة مشاركة الملفات. والمخرج سوف يكون كما يلي:

```text
x86-64 -O2                     175403 bytes of .text in 32 object files
aarch64 -O2                    176196 bytes of .text in 32 object files
riscv64 rv64gc -O2             144244 bytes of .text in 32 object files
riscv64 rv64g (no C) -O2       202684 bytes of .text in 32 object files
x86-64 -Os                     125977 bytes of .text in 32 object files
aarch64 -Os                    145468 bytes of .text in 32 object files
riscv64 rv64gc -Os             121296 bytes of .text in 32 object files
riscv64 rv64g (no C) -Os       172652 bytes of .text in 32 object files
```

والصورة التالية ترسم نفس الأرقام:

![مخطط أعمدة أفقية في مجموعتين: مع -O2 كان حجم كود x86-64 175,403 بايتاً وARM64 176,196 وRISC-V rv64gc 144,244 وRISC-V دون الامتداد C 202,684، ومع -Os كان x86-64 125,977 وARM64 145,468 وrv64gc 121,296 ودون C 172,652، وملاحظة أن الامتداد C وحده وفر 29% من حجم كود RISC-V مع -O2](https://arabroot.io/content/images/2026/11/cisc-vs-risc-04-code-size.webp)

حجم كود الآلة لنواة Lua على المعماريات الثلاث

في المخرج والصورة أعلاه لاحظ التالي:

- **مع `-O2` تعادلت x86-64 وARM64:** الفرق بينهما أقل من نصف في المئة، فالكثافة الشهيرة لـ x86-64 لم تظهر هنا، وأحد أسباب ذلك أن المترجم يحشو كود x86-64 بتعليمات `nop` ليحاذي بدايات الحلقات والدوال، وسوف نعدها في المختبر التالي.
- **مع `-Os` ظهرت الكثافة:** عندما طلبنا من المترجم أن يفضل الحجم صار كود x86-64 أصغر من ARM64 بقرابة 13%، لأن المترجم صار يختار التعليمات القصيرة ولا يحشو للمحاذاة، والأطوال المتغيرة تعطيه هذه المرونة.
- **RISC-V مع الامتداد C هي الأصغر في الحالتين:** 144,244 بايتاً مع `-O2` و121,296 مع `-Os`، أي أن معمارية RISC صممت حديثاً تفوقت في الكثافة على معمارية CISC، وهذا عكس ما تقوله الجداول القديمة.
- **دون الامتداد C صارت RISC-V الأكبر بفارق كبير:** 202,684 بايتاً، أي أن التعليمات المضغوطة وحدها وفرت 29% من الحجم مع `-O2`. فالكثافة ليست صفة لكلمة RISC أو CISC، وإنما لقرار محدد في الترميز: هل توجد صيغة قصيرة للتعليمات الأكثر استخداماً أم لا.

وقد يتساءل البعض: هل هذه المقارنة عادلة، والمترجم واحد ولكن جودة الواجهة الخلفية لكل معمارية مختلفة؟ والإجابة أنها مقارنة لما يحصل عليه مستخدم GCC 14.2 فعلاً، وهذا ما يهمك، ولكن لا تأخذ النسب كقانون، فمترجم آخر مثل Clang أو برنامج آخر قد يغير الترتيب بضع نقاط مئوية.

## المختبر الثاني: كم بايتاً طول التعليمة فعلاً؟

الرقم الكلي لا يخبرك لماذا خرجت النتيجة كذلك، لذلك نعد التعليمات نفسها ونصنفها بحسب طولها. السكربت التالي يترجم نفس الملفات بالخيار `-O2`، ثم يمر على مخرج `objdump` ويحسب طول كل تعليمة من عدد بايتاتها، والخيار `--insn-width=16` يجعل كل تعليمة على سطر واحد مهما طالت، لأن `objdump` يقسم التعليمات الطويلة على سطرين افتراضياً كما رأينا مع `movabs` في المقال السابق:

```bash
#!/bin/bash
# insnlen.sh: how many instructions and how long each one is, in Lua's core at -O2
set -e
tar xzf lua-5.4.9.tar.gz; cd lua-5.4.9/src
SRC=$(ls *.c | grep -v -E '^(lua|luac)\.c$')
stats() {   # $1 = label, $2 = objdump, $3 = compiler, $4.. = flags
  label=$1; od=$2; cc=$3; shift 3
  rm -rf /tmp/o && mkdir /tmp/o
  for f in $SRC; do $cc -O2 "$@" -DLUA_USE_LINUX -c $f -o /tmp/o/${f%.c}.o; done
  $od -d --insn-width=16 /tmp/o/*.o | awk -F'\t' -v L="$label" '
    NF >= 3 && $1 ~ /^ *[0-9a-f]+:$/ {
      n = split($2, b, " "); bytes = 0; for (i = 1; i <= n; i++) bytes += length(b[i]) / 2
      total++; sum += bytes; len[bytes]++; if ($3 ~ /nop/) nops++
    }
    END {
      printf "%s: %d instructions (%d nop), %d bytes, %.2f bytes per instruction\n", L, total, nops, sum, sum / total
      for (k = 1; k <= 15; k++) if (len[k]) printf "  %2d bytes: %6d (%.1f%%)\n", k, len[k], 100 * len[k] / total
    }'
}
stats "x86-64"          objdump                       gcc
stats "aarch64"         aarch64-linux-gnu-objdump     aarch64-linux-gnu-gcc
stats "riscv64 rv64gc"  riscv64-linux-gnu-objdump     riscv64-linux-gnu-gcc -march=rv64gc -mabi=lp64d
stats "riscv64 rv64g"   riscv64-linux-gnu-objdump     riscv64-linux-gnu-gcc -march=rv64g -mabi=lp64d
```

والمخرج سوف يكون كما يلي:

```text
x86-64: 46639 instructions (2560 nop), 175403 bytes, 3.76 bytes per instruction
   1 bytes:   3399 (7.3%)
   2 bytes:   7909 (17.0%)
   3 bytes:  12196 (26.1%)
   4 bytes:   8352 (17.9%)
   5 bytes:   9284 (19.9%)
   6 bytes:   2333 (5.0%)
   7 bytes:   1550 (3.3%)
   8 bytes:    717 (1.5%)
   9 bytes:    235 (0.5%)
  10 bytes:    234 (0.5%)
  11 bytes:    429 (0.9%)
  12 bytes:      1 (0.0%)
aarch64: 44049 instructions (707 nop), 176196 bytes, 4.00 bytes per instruction
   4 bytes:  44049 (100.0%)
riscv64 rv64gc: 50625 instructions (0 nop), 144244 bytes, 2.85 bytes per instruction
   2 bytes:  29128 (57.5%)
   4 bytes:  21497 (42.5%)
riscv64 rv64g: 50671 instructions (0 nop), 202684 bytes, 4.00 bytes per instruction
   4 bytes:  50671 (100.0%)
```

ولاحظ أن مجموع البايتات في كل سطر أول يطابق رقم المختبر الأول تماماً، أي أننا نعد نفس الكود بطريقتين. والصورة التالية ترسم التوزيع:

![مدرج تكراري لأطوال تعليمات x86-64 من بايت واحد إلى 12 بايتاً، أعلاه 26.1% للتعليمات بطول 3 بايتات ثم 19.9% بطول 5 و17.9% بطول 4 و17.0% بطول 2 و7.3% بطول بايت واحد، ثم نسب صغيرة للأطوال الأكبر، وبجانبه ثلاث بطاقات: ARM64 كل تعليماتها 4 بايتات، وRISC-V rv64gc منها 57.5% ببايتين و42.5% بأربعة، وRISC-V rv64g كلها 4 بايتات، وفي الأسفل متوسط الطول 3.76 و4.00 و2.85 بايتاً](https://arabroot.io/content/images/2026/11/cisc-vs-risc-05-insn-length.webp)

توزيع أطوال التعليمات في نواة Lua مع -O2

في المخرج والصورة أعلاه لاحظ التالي:

- **متوسط x86-64 قرابة 3.8 بايتات:** قريب من أربعة، فالتعليمات القصيرة جداً قليلة، وأغلب التعليمات بين بايتين وخمسة. والسبب أن العمل على مسجلات 64 بت يحتاج بادئة REX بايتاً إضافياً في أغلب التعليمات، مثل البايت `48` الذي رأيناه في بداية تعليمات المقال السابق، فالمعمارية التي صممت للمسجلات الثمانية القديمة تدفع بايتاً إضافياً لتصل إلى الستة عشر.
- **لم تظهر تعليمة بطول 13 أو 14 أو 15:** الحد الأقصى 15 بايتاً موجود في العقد، ولكن المترجم لم يحتج أكثر من 12 بايتاً، ومرة واحدة فقط في 46 ألف تعليمة.
- **2,560 تعليمة `nop` في x86-64 مقابل 707 في ARM64:** هذه التعليمات لا تفعل شيئاً، وإنما تحاذي بدايات الحلقات على عناوين مضاعفة لـ 16 لأن جلبها أسرع، وهي جزء من سبب تعادل الحجم مع `-O2`.
- **RISC-V نفذت عدداً أكبر من التعليمات بحجم أصغر:** 50,625 تعليمة مقابل 44,049 في ARM64، أي أكثر بقرابة 15%، لأن تعليماتها أبسط، فبناء رقم كبير مثلاً يحتاج تعليمات أكثر كما رأينا مع الرقم السحري في المقال السابق. ولكن أكثر من نصفها ببايتين، فخرج الحجم الكلي أصغر.

## المختبر الثالث: كم تعليمة ينفذ المعالج لنفس العمل؟

حجم الكود شيء، وعدد التعليمات التي ينفذها المعالج فعلاً شيء آخر، لأن الحلقة الصغيرة قد تتكرر ملايين المرات. والبرنامج التالي فيه ثلاثة أعمال مختلفة الطبيعة، كل منها يمثل نوعاً من الكود: هاش CRC32 يعتمد على عمليات البتات، وجمع مصفوفة يعتمد على قراءة الذاكرة، وترتيب بالدالة `qsort` يعتمد على الاستدعاءات والتفرعات. والمعامل الثاني يختار أي الأعمال تعمل، حتى نعد كل عمل وحده:

```c
// work.c: three small jobs, run N times, to count executed instructions per ISA
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static unsigned crc32(const unsigned char *p, size_t n)       // bit operations
{
    unsigned c = 0xFFFFFFFFu;
    for (size_t i = 0; i < n; i++) {
        c ^= p[i];
        for (int k = 0; k < 8; k++)
            c = (c >> 1) ^ (0xEDB88320u & -(c & 1));
    }
    return ~c;
}

static long total(const long *v, long n)                       // memory + add
{
    long s = 0;
    for (long i = 0; i < n; i++)
        s += v[i] * 3 + (v[i] >> 2);
    return s;
}

static int cmp(const void *a, const void *b)                    // calls + branches
{
    int x = *(const int *)a, y = *(const int *)b;
    return (x > y) - (x < y);
}

int main(int argc, char **argv)
{
    int rounds = argc > 1 ? atoi(argv[1]) : 1;
    int jobs = argc > 2 ? atoi(argv[2]) : 7;          // 1 = crc32, 2 = total, 4 = qsort
    static unsigned char buf[4096];
    static long v[4096];
    static int s[2000];
    unsigned h = 0; long t = 0;
    for (int i = 0; i < 4096; i++) { buf[i] = (unsigned char)(i * 7); v[i] = i * 13 % 1000; }
    for (int r = 0; r < rounds; r++) {
        if (jobs & 1) h ^= crc32(buf, sizeof buf);
        if (jobs & 2) t += total(v, 4096);
        for (int i = 0; i < 2000; i++) s[i] = (i * 7919 + r) % 2000;
        if (jobs & 4) qsort(s, 2000, sizeof s[0], cmp);
    }
    printf("rounds=%d crc=%08x total=%ld min=%d\n", rounds, h, t, s[0]);
    return 0;
}
```

وكيف نعد التعليمات المنفذة على ARM64 وRISC-V ونحن لا نملك هذه المعالجات؟ المحاكي QEMU يترجم الكود إلى كتل Translation Blocks، ويستطيع أن يسجل كل كتلة قبل تنفيذها بالخيار `-d exec`، فإذا أجبرناه بالخيار `-one-insn-per-tb` أن يجعل كل كتلة تعليمة واحدة، وبالخيار `nochain` ألا يربط الكتل ببعضها فيتجاوز التسجيل، صار عدد الأسطر في السجل هو عدد التعليمات المنفذة بالضبط. والخيارات موثقة في [توثيق QEMU لوضع المستخدم](https://www.qemu.org/docs/master/user/main.html?ref=arabroot.io)، والسكربت كما يلي:

```bash
#!/bin/bash
# count.sh: executed guest instructions with QEMU (one instruction per block, log each executed block)
# usage: count.sh <qemu> <binary> <args>
q=$1; shift
$q -one-insn-per-tb -d exec,nochain -D /dev/stdout "$@" | grep -c '^Trace'
```

نترجم البرنامج لكل معمارية بالخيار `-O2` ملفاً ثابتاً، ثم نعد عشر جولات من كل عمل، والعمل رقم 0 يعني دون أي عمل، أي البدء وملء المصفوفات وحلقة التهيئة فقط، حتى نطرحه من الباقي:

```bash
gcc -O2 -static work.c -o work-x86_64
aarch64-linux-gnu-gcc -O2 -static work.c -o work-aarch64
riscv64-linux-gnu-gcc -O2 -static work.c -o work-riscv64
for a in x86_64 aarch64 riscv64; do for j in 0 1 2 4; do
  echo "$a jobs=$j $(bash count.sh qemu-$a ./work-$a 10 $j)"
done; done
```

والمخرج سوف يكون كما يلي، وقد أخذ قرابة ثلاث دقائق لأن تسجيل كل تعليمة يبطئ المحاكي كثيراً:

```text
x86_64 jobs=0 418797
x86_64 jobs=1 3367968
x86_64 jobs=2 746670
x86_64 jobs=4 6262459
aarch64 jobs=0 172657
aarch64 jobs=1 2056848
aarch64 jobs=2 418556
aarch64 jobs=4 4862518
riscv64 jobs=0 380174
riscv64 jobs=1 2878783
riscv64 jobs=2 708016
riscv64 jobs=4 6138796
```

وبعد طرح سطر `jobs=0` من كل معمارية نحصل على عدد التعليمات لكل عمل وحده، وهو ما ترسمه الصورة التالية مع الحلقة الداخلية لهاش CRC32 كما كتبها المترجم في كل معمارية:

![ثلاث مجموعات من الأعمدة: في هاش CRC32 نفذت x86-64 2,949,171 تعليمة وARM64 1,884,191 وRISC-V 2,498,609، وفي جمع المصفوفة نفذت x86-64 327,873 وARM64 245,899 وRISC-V 327,842، وفي الترتيب qsort نفذت x86-64 5,843,662 وARM64 4,689,861 وRISC-V 5,758,622، وتحتها الحلقة الداخلية لكل بت في CRC32: ثماني تعليمات في x86-64 أولها mov، وخمس في ARM64 منها sbfx وeor مع إزاحة، وسبع في RISC-V](https://arabroot.io/content/images/2026/11/cisc-vs-risc-06-executed.webp)

التعليمات المنفذة لعشر جولات من كل عمل، بعد طرح تعليمات البدء

والنتيجة هنا تعاكس ما يتوقعه أغلب الناس: x86-64، صاحبة التعليمات الغنية، نفذت أكبر عدد من التعليمات في الأعمال الثلاثة، وARM64 نفذت الأقل في الأعمال الثلاثة، وRISC-V بينهما. ولنفهم السبب ننظر إلى الحلقة الداخلية لهاش CRC32، وهي تتكرر 8 مرات لكل بايت، أي 327,680 مرة في عشر جولات على 4096 بايتاً:

- **x86-64 ثماني تعليمات:** المترجم يحتاج القيمة `c` مرتين، مرة ليأخذ البت الأدنى ومرة ليزيحها، وتعليمة `and` في x86-64 تكتب فوق مصدرها، فاضطر إلى نسخها أولاً بالتعليمة `mov %eax,%ecx`. وهذه التعليمة الإضافية ثمن العقد ذي المعاملين، وتتكرر 327 ألف مرة.
- **ARM64 خمس تعليمات:** التعليمة `sbfx` تأخذ البت الأدنى وتمده إلى كل البتات في خطوة واحدة، أي أنها تصنع القناع `-(c & 1)` كاملاً، والتعليمة `eor w1, w0, w1, lsr #1` تزيح أحد المعاملين وتطبق XOR في نفس التعليمة، والتعليمة `subs` تطرح وتكتب الأعلام معاً. فالمعمارية «البسيطة» هنا عندها تعليمات أقوى من x86-64 لهذا النوع من العمل.
- **RISC-V سبع تعليمات:** ثلاثة معاملات فلا تحتاج نسخة كما في x86-64، ولكنها لا تملك إزاحة داخل التعليمة الحسابية ولا تعليمة مثل `sbfx`، فتحتاج `andi` ثم `negw` لصنع القناع، وتعليمة منفصلة للإزاحة.

وفي جمع المصفوفة تساوت x86-64 وRISC-V تقريباً، 327,873 مقابل 327,842، بينما نفذت ARM64 أقل بالربع، لأنها تستطيع أن تحسب `v[i] * 3` بتعليمة جمع واحدة مع إزاحة `add x, x, x, lsl #1`، وأن تزيد المؤشر داخل تعليمة التحميل. أما في الترتيب فالجزء الأكبر من العمل داخل الدالة `qsort` من مكتبة glibc، وهي نفس الكود المصدري للمعماريات الثلاث، والفرق جاء من تفاصيل مشابهة في كل استدعاء ومقارنة.

⚠️

عند تشغيل العمل رقم 1 وحده سوف ترى في المخرج `crc=00000000`، وقد يبدو هذا خطأ في الهاش، ولكنه صحيح: البرنامج يطبق XOR على نتيجة نفس الهاش لنفس البيانات عشر مرات، والقيمة مع نفسها عدداً زوجياً من المرات تعطي صفراً. وهذا تذكير بأن تتحقق دائماً من أن البرنامج الذي تقيسه يعمل العمل الذي تظنه قبل أن تثق في الأرقام، وقد تحققنا هنا من القيمة الحقيقية للهاش بتشغيل جولة واحدة، فكانت `d3b3c7bc` على المعماريات الثلاث.

### ماذا يحدث إذا ترجمنا بالخيار -Os؟

رأينا في المختبر الأول أن `-Os` يصغر الكود كثيراً، فهل يعني الكود الأصغر تعليمات منفذة أقل؟ أعدنا نفس العد لعملي الهاش والجمع بعد الترجمة بالخيار `-Os`:

```bash
gcc -Os -static work.c -o os-x86_64
aarch64-linux-gnu-gcc -Os -static work.c -o os-aarch64
riscv64-linux-gnu-gcc -Os -static work.c -o os-riscv64
for a in x86_64 aarch64 riscv64; do for j in 0 1 2; do
  echo "$a -Os jobs=$j $(bash count.sh qemu-$a ./os-$a 10 $j)"
done; done
```

والمخرج سوف يكون كما يلي:

```text
x86_64 -Os jobs=0 345390
x86_64 -Os jobs=1 3212629
x86_64 -Os jobs=2 673201
aarch64 -Os jobs=0 280856
aarch64 -Os jobs=1 2165055
aarch64 -Os jobs=2 567693
riscv64 -Os jobs=0 259872
riscv64 -Os jobs=1 2799459
riscv64 -Os jobs=2 546772
```

وبعد طرح سطر البدء صار هاش CRC32 على x86-64 قرابة 2.87 مليون تعليمة بدلاً من 2.95، أي أقل قليلاً، وبقي على ARM64 كما هو تقريباً عند 1.88 مليون، وزاد على RISC-V من 2.50 إلى 2.54 مليون. أما جمع المصفوفة فبقي على x86-64 كما هو، وزاد على ARM64 من 246 ألفاً إلى 287 ألفاً، ونقص على RISC-V من 328 ألفاً إلى 287 ألفاً. فالنتيجة مختلطة: الخيار `-Os` لا يعد بتعليمات منفذة أقل ولا أكثر، وإنما بكود أصغر، والمترجم يختار تعليمات مختلفة بحسب ما يعرفه عن كل معمارية. وهذا سبب إضافي ألا تحكم على معمارية من رقم واحد، فمجرد تغيير خيار التحسين غير ترتيب المعماريات في عمل جمع المصفوفة.

### هل نثق في عد المحاكي؟ التحقق بعدادات العتاد

قد يتساءل البعض: هل يعد QEMU التعليمات كما يعدها المعالج الحقيقي؟ نستطيع أن نجيب على x86-64 على الأقل، لأن معالج جهاز التجارب x86-64، وفيه عدادات أداء عتادية Performance Counters تقرؤها الأداة [perf stat](https://man7.org/linux/man-pages/man1/perf-stat.1.html?ref=arabroot.io). والمحاولة الأولى داخل Container عادي فشلت كما يلي:

```text
perf version 7.1.5
Error:
No supported events found.
No permission to enable instructions event.
```

والسبب أن الوصول إلى عدادات المعالج يحتاج صلاحيات لا يعطيها Docker افتراضياً، والقيمة في `/proc/sys/kernel/perf_event_paranoid` كانت 2، فشغلنا Container مؤقتاً بالخيار `--privileged` من Image صغيرة من Alpine فيها `perf`، والسكربت كما يلي:

```bash
#!/bin/sh
# perf.sh: hardware counters for the native x86-64 build (needs --privileged on Docker Desktop)
apk add -q perf >/dev/null 2>&1
perf --version
for j in 0 1 2 4; do
  echo "### jobs=$j"
  perf stat -e instructions:u,cycles:u ./work-x86_64 10 $j 2>&1 | grep -E 'rounds|instructions|cycles|elapsed'
done
```

```bash
docker run --rm --privileged --name cs1-perf -v "$PWD:/lab" -w /lab alpine:latest sh perf.sh
```

والمخرج سوف يكون كما يلي:

```text
perf version 7.1.5
### jobs=0
rounds=10 crc=00000000 total=0 min=9
            425140      instructions:u
            595681      cycles:u
       0.202905871 seconds time elapsed
### jobs=1
rounds=10 crc=00000000 total=0 min=9
           3374310      instructions:u
           1955919      cycles:u
       0.559558774 seconds time elapsed
### jobs=2
rounds=10 crc=00000000 total=66228740 min=9
            753012      instructions:u
            728927      cycles:u
       0.165250077 seconds time elapsed
### jobs=4
rounds=10 crc=00000000 total=0 min=0
           6268804      instructions:u
           4815905      cycles:u
       0.291835377 seconds time elapsed
```

في المخرج أعلاه لاحظ التالي:

- **الحرف `u` بعد اسم العداد:** يعني أننا نعد ما ينفذ في وضع المستخدم فقط، دون تعليمات النواة، لأن المحاكي أيضاً لا يعد إلا تعليمات البرنامج.
- **الفرق ثابت تقريباً:** المعالج الحقيقي عد 425,140 تعليمة دون عمل، والمحاكي عد 418,797، والفرق 6,343، وفي العمل رقم 1 الفرق 6,342، وفي رقم 2 الفرق 6,342، وفي رقم 4 الفرق 6,345\. أي أن الفرق في كود البدء فقط، مثل أجزاء من مكتبة C تفحص ميزات المعالج فتسلك طريقاً مختلفاً تحت المحاكي، أما عد العمل نفسه فمتطابق حتى آخر تعليمة تقريباً، فنستطيع أن نثق في أرقام ARM64 وRISC-V بنفس الطريقة.
- **التعليمات في كل نبضة IPC:** في هاش CRC32، بعد طرح سطر البدء، نفذ المعالج 2,949,170 تعليمة في 1,360,238 نبضة، أي قرابة 2.2 تعليمة في كل نبضة، وفي الترتيب قرابة 1.4 فقط، لأن تفرعات المقارنة في الترتيب صعبة التوقع. فعدد التعليمات وحده لا يخبرك بالوقت، ومعالج ينفذ تعليمات أكثر قد ينهي العمل أسرع إذا نفذ عدداً أكبر منها في كل نبضة.

### كم عملية صغيرة أصبحت هذه التعليمات؟

عدادات معالجات Intel تعد أيضاً العمليات الصغيرة، ولكنها عدادات خاصة بكل معمارية دقيقة، وأرقامها موجودة في [قائمة أحداث Skylake في مستودع Intel perfmon](https://github.com/intel/perfmon/blob/main/SKL/events/skylake%5Fcore.json?ref=arabroot.io)، وهي نفس القائمة التي يستخدمها معالج Kaby Lake في جهاز التجارب لأن رقم طرازه 158 أي `0x9E`. ومنها حدثان: `UOPS_ISSUED.ANY` بالرمز `0x0E` والقناع `0x01`، وهو العمليات التي أرسلتها المقدمة إلى محرك التنفيذ، و`UOPS_RETIRED.RETIRE_SLOTS` بالرمز `0xC2` والقناع `0x02`، وهو العمليات التي اكتملت فعلاً. ونكتبهما لـ `perf` بالصيغة الخام `r010e` و`r02c2`:

```bash
#!/bin/sh
# uops.sh: instructions vs micro-ops on Kaby Lake (raw events: UOPS_ISSUED.ANY = r010e, UOPS_RETIRED.RETIRE_SLOTS = r02c2)
apk add -q perf >/dev/null 2>&1
for j in 0 1 2 4; do
  echo "### jobs=$j"
  perf stat -e instructions:u,r010e:u,r02c2:u ./work-x86_64 10 $j 2>&1 | grep -E 'instructions|r010e|r02c2'
done
```

والمخرج سوف يكون كما يلي:

```text
### jobs=0
            425139      instructions:u
            461080      r010e:u
            436804      r02c2:u
### jobs=1
           3374312      instructions:u
           3070618      r010e:u
           3022405      r02c2:u
### jobs=2
            753013      instructions:u
            750203      r010e:u
            724306      r02c2:u
### jobs=4
           6268804      instructions:u
           7136438      r010e:u
           6044600      r02c2:u                                                               
```

في المخرج أعلاه لاحظ التالي:

- **في هاش CRC32 العمليات أقل من التعليمات:** بعد طرح سطر البدء، 2,949,173 تعليمة أصبحت 2,585,601 عملية مكتملة، أي أقل بقرابة 364 ألفاً، وهو رقم قريب جداً من عدد مرات الحلقة الداخلية 327,680 زائد الحلقة الخارجية 40,960\. والتفسير أن كل زوج من `sub` و`jne` في آخر الحلقة اندمج في عملية واحدة Macro-fusion، فالمقدمة «أصلحت» جزءاً من كلفة العقد.
- **في جمع المصفوفة قرابة عملية لكل تعليمة:** 327,874 تعليمة أصبحت 287,502 عملية، فالدمج حدث هنا أيضاً، ولم تحتج أي تعليمة إلى تقسيم كبير.
- **في الترتيب صدر أكثر مما اكتمل:** المقدمة أرسلت قرابة 6.7 ملايين عملية بعد طرح البدء، واكتمل منها قرابة 5.6 ملايين فقط، والفرق أكثر من مليون عملية نفذت على مسار خاطئ بعد توقع تفرع خاطئ ثم ألغيت، وهذا ما شرحناه في [مقال المعالج من الداخل](https://arabroot.io/articles/%D9%83%D9%8A%D9%81-%D9%8A%D8%B9%D9%85%D9%84-%D8%A7%D9%84%D9%85%D8%B9%D8%A7%D9%84%D8%AC-cpu-%D9%85%D9%86-%D8%A7%D9%84%D8%AF%D8%A7%D8%AE%D9%84/#branch-prediction).

وبالتالي فالعقد x86-64 يجبر المترجم أحياناً على تعليمات إضافية، مثل `mov` في هاش CRC32، ولكن المعالج الحديث يسترد جزءاً من ذلك داخلياً، والأرقام النهائية التي تهمك، أي الوقت والطاقة، تحددها هذه التفاصيل الداخلية أكثر مما يحددها اسم الفلسفة.

## هل RISC أوفر في الطاقة؟

هذا أكثر سؤال يتكرر، وأفضل إجابة منشورة عليه دراسة من جامعة Wisconsin عنوانها [Power Struggles: Revisiting the RISC vs. CISC Debate](https://research.cs.wisc.edu/vertical/papers/2013/hpca13-isa-power-struggles.pdf?ref=arabroot.io)، نشرت في مؤتمر HPCA سنة 2013\. قاس الباحثون معالجات حقيقية من الفريقين، ARM Cortex-A8 وCortex-A9 وIntel Atom وIntel Core i7 من جيل Sandy Bridge، على برامج للهاتف والحاسب والسيرفر، وقاسوا الأداء والطاقة معاً، وكانت خلاصتهم أن معالجات ARM وx86 مجرد نقاط تصميم هندسية حسنت لمستويات أداء مختلفة، وأنه لا يوجد شيء في أي من الفلسفتين يجعلها أوفر في الطاقة بطبيعتها، وأن كون ال ISA من نوع RISC أو CISC لا يبدو مهماً.

فلماذا إذن تبدو أجهزة Mac الحديثة وسيرفرات ARM أوفر؟ والإجابة أن الطاقة تأتي من قرارات كثيرة لا علاقة لها بالفلسفة: تقنية التصنيع بالنانومتر، وعدد الأنوية الصغيرة الموفرة، وحجم ال Cache، والتردد الذي صممت له الشريحة، ودمج الذاكرة قرب المعالج، وحتى أهداف الشركة نفسها، فشركة صممت معالجاً لهاتف ثم كبرته وضعت الطاقة أولاً، وشركة صممت معالجاً لحاسب مكتبي ثم صغرته وضعت الأداء أولاً. وقد يكون لفك الطول المتغير ثمن حقيقي في الطاقة، ولكنه جزء صغير من الشريحة، خاصة مع ذاكرة العمليات uop Cache التي تجنب المعالج الفك في أغلب الوقت.

📌

في 2023 نشرت Intel وصف امتداد جديد لـ x86-64 اسمه [Advanced Performance Extensions](https://www.intel.com/content/www/us/en/developer/articles/technical/advanced-performance-extensions-apx.html?ref=arabroot.io)، واختصاراً APX، وهو يضاعف المسجلات العامة من 16 إلى 32، ويضيف صيغة بثلاثة معاملات لتعليمات الحساب القديمة حتى لا يحتاج المترجم نسخ القيم قبل العمليات، أي نفس التعليمة `mov` التي رأيناها في هاش CRC32\. وتذكر Intel في نفس الصفحة أن محاكاتها على برامج SPEC CPU 2017 أعطت قرابة 10% تعليمات تحميل أقل، وأكثر من 20% تعليمات تخزين أقل، وقرابة 10% تعليمات أقل. والدرس أن أقدم معمارية CISC تضيف اليوم صفتين من صفات RISC الكلاسيكية، لأن الأرقام تقول إنهما تنفعان.

## إذا كانت RISC أفضل نظرياً، فلماذا فازت x86 بالحاسب؟

في نهاية الثمانينات كانت محطات العمل المبنية على معالجات RISC، مثل SPARC وMIPS وPOWER، أسرع بوضوح من حواسب x86 في نفس السعر، وكان كثير من المهندسين يتوقعون أن تختفي x86 خلال سنوات. وما حدث هو العكس، والسبب لم يكن تقنياً بقدر ما كان اقتصادياً: حواسب IBM PC ونسخها كانت تباع بالملايين، وكل البرامج التجارية مترجمة لـ x86، فكانت Intel تبيع أكثر من أي شركة RISC، وتنفق من هذه المبيعات على مصانع أحدث وفرق تصميم أكبر، فتعوض بالتصنيع والمعمارية الدقيقة ما تخسره في العقد. ولما جاء Pentium Pro بالعمليات الصغيرة والتنفيذ خارج الترتيب صار الفرق في السرعة صغيراً، وبقي توافق البرامج القديمة ميزة لا تملكها أي معمارية أخرى.

وأوضح مثال على ذلك قصة Apple نفسها: في 1993 تحالفت مع IBM وMotorola على معالجات PowerPC، وهي RISC، كما تذكر [صفحة تاريخ IBM](https://www.ibm.com/history/risc?ref=arabroot.io)، ثم في يونيو 2005 [أعلنت انتقالها إلى معالجات Intel](https://www.apple.com/newsroom/2005/06/06Apple-to-Use-Intel-Microprocessors-Beginning-in-2006/?ref=arabroot.io) لأن خطط PowerPC لم تعد تعطيها الأداء مقابل الطاقة الذي تحتاجه لأجهزتها المحمولة، ثم في يونيو 2020 [أعلنت انتقالها إلى معالجات ARM](https://www.apple.com/newsroom/2020/06/apple-announces-mac-transition-to-apple-silicon/?ref=arabroot.io) تصممها بنفسها. فنفس الشركة انتقلت من RISC إلى CISC ثم إلى RISC، وفي كل مرة كان السبب الأداء مقابل الطاقة الذي تقدمه الشرائح المتوفرة في ذلك الوقت، وليس فلسفة العقد.

وفي الهاتف حدث العكس لنفس السبب الاقتصادي: معالجات ARM كانت أصغر وأقل استهلاكاً من البداية، وتباع رخصتها لأي شركة تريد أن تضعها في شريحة مع أجزاء أخرى، فصارت هي المعمارية التي تكتب لها كل برامج الهاتف، ولما حاولت Intel أن تدخل الهاتف بمعالجات Atom كان التوافق هذه المرة ميزة لـ ARM وليس لـ x86\. والدرس العملي هنا أن كمية البرامج المترجمة لعقد معين، أي النظام البيئي Ecosystem، أقوى من أي فرق تقني بين العقود، وهذا ما يجعل الانتقال بين المعماريات بطيئاً ومكلفاً كما رأينا في المقال السابق.

## أين ما زال الفرق مهماً اليوم؟

إذا لم يكن الفرق في الطاقة ولا في عدد التعليمات بالضرورة، فأين يظهر فعلاً؟ هناك أربعة أماكن حقيقية:

1. **عرض الفك:** كلما أراد المصمم أن يفك تعليمات أكثر في كل نبضة صار الطول المتغير أصعب، لأن تحديد الحدود عمل متسلسل بطبيعته، بينما الطول الثابت يسمح بمفككات أكثر بسهولة. وهذا قيد في التصميم يدفع ثمنه مهندسو Intel وAMD بالترانزستورات وذاكرة العمليات، وليس أنت كمطور.
2. **نموذج الذاكرة Memory Model:** معالجات x86-64 تضمن ترتيباً قوياً نسبياً لقراءة الذاكرة وكتابتها بين الأنوية كما يصف [دليل Intel](https://www.intel.com/content/www/us/en/developer/articles/technical/intel-sdm.html?ref=arabroot.io)، بينما ARM64 أضعف في الترتيب ويحتاج تعليمات حواجز Barriers صريحة أكثر، كما يعرف [دليل معمارية Arm](https://developer.arm.com/documentation/ddi0487/latest?ref=arabroot.io). والكود الذي فيه خطأ تزامن قد يعمل سنوات على x86-64 ثم يظهر خطؤه أول مرة على سيرفر ARM، وهذا فرق يهمك أنت مباشرة إذا كتبت كوداً متعدد الخيوط دون أقفال صحيحة.
3. **التاريخ المتراكم:** x86-64 تحمل كل ما أضيف منذ 1978، من الوضع الحقيقي ذي 16 بت إلى تعليمات الفاصلة العائمة القديمة x87، والمعالج الحديث ما زال يقلع بنفس الطريقة التي أقلع بها 8086، وهذا موضوع مقال قصة x86 في نفس المرحلة. أما ARM64 فقطعت مع تاريخ ARM 32 بت في تصميم جديد، وRISC-V بدأت من صفحة بيضاء.
4. **الرخصة والسوق:** لا يصنع معالجات x86-64 إلا Intel وAMD تقريباً، بينما تبيع Arm رخصة معماريتها لمن يريد، وRISC-V مفتوحة دون رسوم كما تذكر [صفحتها](https://riscv.org/about/?ref=arabroot.io). وهذا الفرق يحدد من يستطيع أن يصمم شريحته بنفسه، مثل Apple وAmazon وGoogle، أكثر مما يحدده أي فرق تقني.

ولاحظ أن الاتجاه منذ سنوات هو التقارب: x86-64 أضافت مسجلات وثلاثة معاملات في APX، وARM64 أضافت تعليمات معقدة للمتجهات والتشفير مثل امتدادات SVE وAES، وتعليمات تحمل مسجلين في خطوة مثل `ldp`، وRISC-V أضافت الامتداد C الذي يجعل طول التعليمة متغيراً بين قيمتين. فالفلسفتان كانتا في السبعينات قطبين، واليوم كل معمارية كبيرة تأخذ من الأخرى ما تثبت الأرقام أنه ينفع.

## أخطاء شائعة

- القول إن RISC تعني تعليمات أقل في البرنامج دائماً: في مختبرنا نفذت ARM64 تعليمات أقل من x86-64 في الأعمال الثلاثة، ونفذت RISC-V قرابة نفس عدد x86-64.
- القول إن CISC تعني كوداً أصغر دائماً: مع `-O2` تعادلت x86-64 مع ARM64، وكانت RISC-V مع الامتداد C الأصغر في كل الحالات.
- القول إن معالجات x86 «RISC من الداخل» فلا فرق: المحرك الداخلي منتظم فعلاً، ولكن المقدمة تدفع ثمن فك العقد القديم، والعقد نفسه يجبر المترجم أحياناً على تعليمات إضافية كما رأينا.
- نسب كفاءة الطاقة إلى الفلسفة: الدراسات التي قاست معالجات حقيقية وجدت أن التصميم الداخلي وتقنية التصنيع هما ما يحددان الطاقة.
- مقارنة عدد التعليمات كأنه الوقت: معالج Intel في مختبرنا نفذ 2.2 تعليمة في كل نبضة في عمل، و1.4 في عمل آخر، والوقت هو التعليمات مقسومة على هذا الرقم ومضروبة في زمن النبضة.
- نقل أرقام من مقال إلى قرار شراء: كل الأرقام هنا لبرنامجين محددين ومترجم محدد، فاختبر خدمتك أنت على المعالج الذي تفكر فيه.
- تجاهل نموذج الذاكرة عند الانتقال إلى ARM: الكود الذي يعتمد على ترتيب x86-64 القوي دون أقفال صحيحة قد يفشل على ARM64، فراجع كود التزامن قبل الانتقال.

## جدول قرار Decision Table: متى يهمك نوع ال ISA؟

| الموقف                                             | هل يهم RISC أو CISC؟    | ما يهمك فعلاً                                           | ماذا تفعل                                                |
| -------------------------------------------------- | ----------------------- | ------------------------------------------------------- | -------------------------------------------------------- |
| تختار بين سيرفر x86-64 وARM64 في السحابة           | لا تقريباً              | السعر مقابل الأداء لخدمتك، وتوفر كل ال Images والمكتبات | شغل خدمتك واقس الطلبات في الثانية والكلفة على الاثنين    |
| تكتب كوداً متعدد الخيوط بذرات Atomics أو دون أقفال | نعم، بسبب نموذج الذاكرة | الحواجز والترتيب                                        | استخدم ذرات اللغة بترتيب صحيح واختبر على ARM64           |
| جهاز مدمج بذاكرة Flash صغيرة                       | نعم، بسبب كثافة الكود   | حجم الملف التنفيذي                                      | قارن size بالخيار \-Os، وفي RISC-V تأكد من الامتداد C    |
| تكتب كود Assembly أو SIMD يدوياً                   | نعم                     | التعليمات المتاحة في كل معمارية                         | اكتب نسخة لكل معمارية، أو استخدم دوال المترجم Intrinsics |
| تقرأ مقارنة أداء بين معالجين                       | لا                      | المعمارية الدقيقة والتردد وال Cache والبرنامج المقاس    | ابحث عن نتائج على برنامج يشبه عملك                       |
| تبني جهاز Homelab منخفض الاستهلاك                  | لا تقريباً              | استهلاك الشريحة المحددة وهي خاملة                       | اقرأ الاستهلاك الفعلي للجهاز، وليس اسم المعمارية         |

## قائمة تحقق Checklist قبل أن تصدق مقارنة RISC وCISC

- هل المقارنة بين عقدين، أم بين شريحتين، أم بين شركتين؟
- هل الأرقام لنفس المترجم ونفس خيارات التحسين على المعماريات كلها؟
- هل تقيس حجم الكود أم عدد التعليمات المنفذة أم الوقت أم الطاقة؟ فهذه أربعة أشياء مختلفة.
- هل البرنامج المقاس يعمل العمل الذي تظنه؟ تحقق من مخرجه كما فعلنا مع `crc=00000000`.
- هل تقنية التصنيع والتردد والاستهلاك متقاربة بين المعالجين؟
- هل تشبه أعمال المقارنة عملك أنت؟

## حذف المختبر Cleanup

كل ال Containers عملت بالخيار `--rm`، وتبقى ال Images والملفات التي ترجمناها في مجلد المختبر:

```bash
docker rmi cs1-isa:1 alpine:latest
rm -f work-x86_64 work-aarch64 work-riscv64 lua-5.4.9.tar.gz
```

واحذف `alpine:latest` فقط إذا لم تكن تستخدمها في شيء آخر.

## الخلاصة

وصلنا لنهاية الموضوع، وأهم ما فيه:

- CISC وRISC فلسفتان لتصميم العقد ولدتا لحل مشاكل السبعينات: التعليمات الغنية لتوفير الذاكرة، والتعليمات البسيطة لتسريع المعالج بخط التنفيذ.
- منذ Pentium Pro في 1995 تترجم معالجات x86 كل تعليمة إلى عمليات صغيرة Micro-ops ينفذها محرك خارج الترتيب، فصار الفرق في المقدمة التي تجلب وتفك.
- في حجم الكود تعادلت x86-64 وARM64 مع `-O2`، وتفوقت x86-64 مع `-Os`، وكانت RISC-V مع الامتداد C الأصغر دائماً، ودونه الأكبر بفارق 29%.
- متوسط طول تعليمة x86-64 كان 3.76 بايتات، ولم يتجاوز أطولها 12 بايتاً، و2,560 منها `nop` للمحاذاة.
- ARM64 نفذت أقل عدد من التعليمات في الأعمال الثلاثة، وx86-64 الأكثر، والسبب تفاصيل مثل العقد ذي المعاملين والإزاحة داخل التعليمة، وليس اسم الفلسفة.
- عد المحاكي QEMU طابق عدادات العتاد على x86-64 بفرق ثابت في كود البدء فقط، والمعالج الحقيقي دمج تعليمات المقارنة والقفز فاسترد جزءاً من كلفة العقد.
- الدراسات على معالجات حقيقية تقول إن الطاقة يحددها التصميم الداخلي والتصنيع وليس نوع ال ISA، والفرق الذي يهمك فعلاً هو نموذج الذاكرة وتوفر البرامج وكلفة السيرفر.

وفي المقالات التالية من المرحلة نروي قصة x86 من 8086 إلى AMD64، ونقرأ أسماء معالجات Intel وAMD، ثم ننتقل إلى ARM وRISC-V:

[![](https://arabroot.io/content/images/2026/11/x86-history-cover-cover.webp)دليلقصة x86: من Intel 8086 إلى x86-64 الذي صممته AMDكيف وصلت معمارية معالج 16 بت من 1978 إلى أغلب سيرفرات اليوم، ولماذا ما زال معالجك يقلع كأنه 8086، مع قطاع إقلاع يصعد الأوضاع الثلاثة أمامك.](https://arabroot.io/articles/%D9%82%D8%B5%D8%A9-x86-%D9%85%D9%86-intel-8086-%D8%A7%D9%84%D9%89-x86-64-%D9%88-amd64/)[![](https://arabroot.io/content/images/2026/11/intel-amd-families-cover-cover.webp)دليلعائلات Intel وAMD: كيف تقرأ اسم المعالج وجيله؟نفك أسماء معالجات Intel وAMD من المصادر الرسمية، ثم نقرأ معالجاً حقيقياً بأدوات Windows وLinux ونفك هويته الرقمية التي لا تتغير مع الاسم.](https://arabroot.io/articles/%D8%B9%D8%A7%D8%A6%D9%84%D8%A7%D8%AA-intel-%D9%88-amd-%D9%83%D9%8A%D9%81-%D8%AA%D9%82%D8%B1%D8%A7-%D8%A7%D8%B3%D9%85-%D8%A7%D9%84%D9%85%D8%B9%D8%A7%D9%84%D8%AC-%D9%88%D8%AC%D9%8A%D9%84%D9%87/)[![](https://arabroot.io/content/images/2026/11/arm-everywhere-cover-cover.webp)دليلARM من الجوال إلى السيرفر: Apple Silicon وGravitonكيف تربح Arm من شرائح لا تصنعها، ولماذا صار في كل سحابة معالج ARM، مع مختبر يبني Image لـ arm64 ويقيس كلفة تشغيلها تحت المحاكاة.](https://arabroot.io/articles/arm-%D9%85%D9%86-%D8%A7%D9%84%D8%AC%D9%88%D8%A7%D9%84-%D8%A7%D9%84%D9%89-%D8%A7%D9%84%D8%B3%D9%8A%D8%B1%D9%81%D8%B1-apple-silicon-%D9%88-graviton/)[![](https://arabroot.io/content/images/2026/11/risc-v-cover-cover.webp)دليلRISC-V: المعمارية المفتوحة وهل تغير سوق المعالجات؟ما الذي يعنيه أن تكون معمارية المعالج مفتوحة، وكيف تقرأ امتدادات RISC-V وملفاتها التعريفية، مع مختبر يقلع Debian كاملاً على RISC-V داخل QEMU.](https://arabroot.io/articles/risc-v-%D8%A7%D9%84%D9%85%D8%B9%D9%85%D8%A7%D8%B1%D9%8A%D8%A9-%D8%A7%D9%84%D9%85%D9%81%D8%AA%D9%88%D8%AD%D8%A9-%D9%88%D9%87%D9%84-%D8%AA%D8%BA%D9%8A%D8%B1-%D8%B3%D9%88%D9%82-%D8%A7%D9%84%D9%85%D8%B9%D8%A7%D9%84%D8%AC%D8%A7%D8%AA/)[![](https://arabroot.io/content/images/2026/11/emulation-translation-cover-cover.webp)دليلالمحاكاة Emulation والترجمة الثنائية: QEMU وRosetta 2نفتح محاكي QEMU ونرى كيف تتحول تعليمات ARM إلى تعليمات x86 ونقيس كلفة كل خطوة، ثم نقارن ذلك بما تفعله Rosetta 2 وWindows Prism.](https://arabroot.io/articles/%D8%A7%D9%84%D9%85%D8%AD%D8%A7%D9%83%D8%A7%D8%A9-emulation-%D9%88%D8%A7%D9%84%D8%AA%D8%B1%D8%AC%D9%85%D8%A9-%D8%A7%D9%84%D8%AB%D9%86%D8%A7%D8%A6%D9%8A%D8%A9-qemu-%D9%88-rosetta-2/)

## سجل التحديثات

- 16 نوفمبر 2026: كتابة المقال، وتنفيذ التجارب داخل Container من Debian 13 (trixie) مع GCC 14.2 والمترجمين المتقاطعين لـ aarch64 وriscv64 وQEMU 10.0.13، على كود Lua 5.4.9، وقراءة عدادات العتاد بالأداة perf 7.1.5 داخل Container من Alpine، على نواة Linux 5.15 (WSL2) ومعالج Intel Core i7-7700K، على Docker Engine 29.8.0.