> ## 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.

# زمن الاستجابة Latency والإنتاجية Throughput بالأرقام
- URL: https://arabroot.io/articles/زمن-الاستجابة-latency-والانتاجية-throughput-بالارقام/
- Published: 2026-11-18T11:50:48.000Z
- Updated: 2026-11-18T13:31:13.000Z
- Description: الأرقام التي يحتاجها كل تصميم من الذاكرة إلى القارات، مقاسة على جهاز واحد، مع الذيل Tail Latency وقانون Little واختبار k6 يبين أين تنهار الخدمة.
- Author: فريق عرب رووت
- Tags: الأدلة التقنية, هندسة البرمجيات والـ Backend, DevOps وCI/CD, قواعد البيانات, الاستضافة الذاتية

تكتب صفحة «طلباتي» في تطبيق متجر، وتحتاج الصفحة أن تتحقق من جلسة المستخدم في خدمة الدخول، ثم تجلب آخر عشرين طلباً من قاعدة البيانات، ثم تجلب لكل طلب اسم المنتج وصورته، ثم تسأل شركة الشحن عن حالة كل شحنة عبر واجهتها API. وعلى جهازك تفتح الصفحة في نصف ثانية فتطمئن، ثم تنشرها، فيكتب لك أحد العملاء أن الصفحة تأخذ أربع ثوان، ويرسل لك فريق المراقبة رسماً يبين أن متوسط الصفحة 600 مللي ثانية، وأن واحداً من كل مئة طلب يتجاوز خمس ثوان. وعندما تجلس لتفهم أين ذهب الوقت تكتشف أنك لا تعرف كم يأخذ استعلام واحد في قاعدة البيانات، ولا كم يأخذ طلب HTTP بين خدمتين، ولا لماذا يكون أسوأ طلب أبطأ من المتوسط بعشرة أضعاف.

هذه الأسئلة يجيب عنها مهندس الأنظمة قبل أن يرسم أي صندوق، لأن كل قرار تصميم يعتمد على رقمين: كم يأخذ الطلب الواحد من الوقت، وهو زمن الاستجابة Latency، وكم طلباً يستطيع النظام أن ينجز في الثانية، وهي الإنتاجية Throughput. وقد عرضنا في [مدخل إلى تصميم الأنظمة](https://arabroot.io/articles/%D9%85%D8%AF%D8%AE%D9%84-%D8%A7%D9%84%D9%89-%D8%AA%D8%B5%D9%85%D9%8A%D9%85-%D8%A7%D9%84%D8%A7%D9%86%D8%B8%D9%85%D8%A9-%D9%85%D9%86-%D8%B3%D9%8A%D8%B1%D9%81%D8%B1-%D9%88%D8%A7%D8%AD%D8%AF-%D8%A7%D9%84%D9%89-%D9%85%D9%84%D8%A7%D9%8A%D9%8A%D9%86/) جدول الأرقام المشهور وطريقة التقدير السريع على متجر كامل، أما هذا المقال فيدخل في الأرقام نفسها: من أين جاءت، وكيف تقيسها على جهازك بدل أن تحفظها، ولماذا يكون الذيل أهم من المتوسط، وكيف يربط قانون Little بين الزمن والإنتاجية وعدد الطلبات المعلقة.

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

- الفرق بين زمن الاستجابة Latency والإنتاجية Throughput وعرض النطاق Bandwidth، ولماذا لا يكفي أحدها وحده.
- قصة «الأرقام التي يجب أن يعرفها كل مبرمج» من Peter Norvig إلى Jeff Dean إلى رسم Colin Scott الذي يتابع تغيرها كل سنة.
- سلم الأرقام من النانوثانية إلى الثانية، وما الذي يعنيه الفرق بين كل درجة وأخرى في تصميمك.
- النسب المئوية Percentiles وذيل التوزيع Tail Latency، وفكرة ورقة The Tail at Scale عن الطلب الذي ينتظر مئة خدمة.
- قانون Little's Law، وما يحدث لزمن الاستجابة عندما يقترب الاستخدام Utilization من 100%.
- تمرين تقدير كامل على صفحة «طلباتي» قبل أن تكتب سطراً واحداً.
- تجربة عملية تقيس فيها الأرقام على جهاز واحد: الذاكرة المخبئية Cache والذاكرة RAM والقرص SSD وTCP وRedis وPostgreSQL وDNS والإنترنت، ثم اختبار ضغط بأداة k6 يثبت قانون Little، ثم تجربة الذيل مع الطلبات المتوازية Fan-out.

## ما الفرق بين زمن الاستجابة Latency والإنتاجية Throughput؟

زمن الاستجابة هو الوقت الذي يمضي من لحظة إرسال الطلب إلى لحظة وصول الرد، ويقاس بالثواني وأجزائها: النانوثانية ns وهي جزء من مليار من الثانية، والميكروثانية µs وهي جزء من مليون، والمللي ثانية ms وهي جزء من ألف. أما الإنتاجية فهي عدد العمليات التي ينجزها النظام في وحدة الزمن، مثل عدد الطلبات في الثانية RPS، أو عدد عمليات القرص في الثانية IOPS، أو عدد البايتات في الثانية. والتشبيه الأقرب هو الطريق السريع: زمن الاستجابة هو الوقت الذي تأخذه سيارة واحدة من المدخل إلى المخرج، ويحدده طول الطريق وسرعة السيارة والزحام، والإنتاجية هي عدد السيارات التي تخرج من الطريق في الساعة، ويحددها عدد المسارات قبل أي شيء آخر.

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

وهناك مصطلح ثالث يخلط به كثيرون، وهو عرض النطاق Bandwidth، أي أقصى ما يستطيع الرابط أن ينقله في الثانية، مثل منفذ شبكة 1 Gbps. والإنتاجية هي ما تحققه فعلاً من هذا العرض، وغالباً تكون أقل منه بسبب زمن الاستجابة نفسه، فاتصال TCP واحد لا يرسل أكثر من نافذة Window من البيانات قبل أن ينتظر التأكيد، لذلك نقل ملف كبير عبر رابط بعيد قد لا يستغل إلا جزءاً صغيراً من عرض النطاق المتاح. وقد شرحنا آلية النافذة والتأكيد في مقال [TCP وUDP وDHCP](https://arabroot.io/articles/tcp-%D9%88-udp-%D9%88-dhcp-%D8%A8%D8%A8%D8%B3%D8%A7%D8%B7%D8%A9/).

وعندما نقول «زمن الاستجابة» عن طلب HTTP فهو في الحقيقة مجموع أجزاء: زمن الانتظار في الطابور Queueing Time قبل أن يبدأ أحد بخدمة الطلب، ثم زمن الخدمة Service Time الذي يعمل فيه السيرفر فعلاً، ثم زمن الشبكة ذهاباً وإياباً Round Trip Time، واختصاراً RTT. وأغلب المشكلات التي تراها في الإنتاج ليست في زمن الخدمة، وإنما في زمن الانتظار، لأن زمن الخدمة ثابت تقريباً بينما زمن الانتظار يتضاعف مع الضغط، كما سوف ترى بالأرقام.

## من أين جاءت الأرقام التي يجب أن يعرفها كل مبرمج؟ Latency Numbers

في سنة 2001 كتب Peter Norvig مقاله المعروف [Teach Yourself Programming in Ten Years](https://norvig.com/21-days.html?ref=arabroot.io)، ووضع في آخره جدولاً صغيراً عنوانه «الأوقات التقريبية لعمليات مختلفة على جهاز حاسب عادي»، وفيه أن تنفيذ تعليمة واحدة يأخذ نانوثانية، وأن القراءة من الذاكرة الرئيسية تأخذ حوالي 100 نانوثانية، وأن إرسال حزمة من الولايات المتحدة إلى أوروبا والعودة يأخذ 150 مللي ثانية. وكانت فكرته أن المبرمج الجيد يعرف كم يأخذ كل شيء تقريباً، لأن من لا يعرف أن القرص أبطأ من الذاكرة بمئة ألف مرة سوف يكتب برنامجاً بطيئاً دون أن يشعر.

ثم أخذ Jeff Dean من Google هذه الفكرة إلى محاضراته عن بناء الأنظمة الكبيرة، ومنها محاضرته في جامعة Stanford بعنوان [Designs, Lessons and Advice from Building Large Distributed Systems](https://static.googleusercontent.com/media/research.google.com/en//people/jeff/stanford-295-talk.pdf?ref=arabroot.io)، حيث عرض قائمة أطول صارت تسمى «Numbers Everyone Should Know»، وأضاف إليها قفل Mutex وضغط البيانات والقراءة المتتالية من القرص والذهاب والعودة داخل مركز البيانات، وكان يطلب من المهندسين أن يحسبوا أداء التصميم على الورق بهذه الأرقام قبل أن يكتبوا الكود. وانتشرت القائمة بعد ذلك في [نسخة مجمعة على GitHub](https://gist.github.com/jboner/2841832?ref=arabroot.io) بعنوان Latency Numbers Every Programmer Should Know، وهي النسخة التي يقتبسها أغلب الناس اليوم.

والمشكلة أن هذه الأرقام تعود إلى نهاية العقد الأول من هذا القرن، والأجهزة تغيرت منذ ذلك الوقت، لذلك بنى Colin Scott من جامعة Berkeley [رسماً تفاعلياً](https://colin-scott.github.io/personal%5Fwebsite/research/interactive%5Flatency.html?ref=arabroot.io) يقدر كل رقم لأي سنة تختارها بناءً على اتجاهات تطور العتاد. وإذا حركت السنة في الرسم سوف تلاحظ أمرين: الأول أن القرص تغير أكثر من أي شيء آخر، فالقراءة العشوائية التي كانت تأخذ 10 مللي ثوان على القرص الدوار HDD صارت تأخذ عشرات الميكروثواني على SSD، والثاني أن أرقاماً أخرى لم تتغير تقريباً، فالقراءة من الذاكرة الرئيسية ما زالت قرابة 100 نانوثانية، والذهاب والعودة بين القارات ما زال 150 مللي ثانية تقريباً، لأن الأول تحدده فيزياء الذاكرة DRAM والثاني تحدده سرعة الضوء.

لذلك لا تحفظ الأرقام كما هي، وإنما احفظ النسب بينها ورتبة كل رقم Order of Magnitude، أي هل هو نانوثانية أم ميكروثانية أم مللي ثانية، ثم قس الأرقام على أجهزتك أنت، وهذا ما سوف نقوم به في التجربة. والخلاصة التي لم تتغير منذ Norvig: كل درجة في السلم أبطأ من التي قبلها بعشرة أضعاف إلى ألف ضعف، والفرق بين أن تبقى البيانات في الذاكرة وأن تخرج إلى الشبكة هو الفرق بين تصميم سريع وتصميم بطيء.

## سلم الأرقام: من النانوثانية إلى الثانية Orders of Magnitude

الطريقة الأسهل لتتذكر السلم أن تقسمه إلى أربع طبقات، ولكل طبقة سؤال واحد في التصميم:

- **النانوثواني (داخل المعالج والذاكرة):** الذاكرة المخبئية L1 حوالي نانوثانية، وL2 بضع نانوثوان، وL3 عشرات النانوثواني، والذاكرة الرئيسية RAM قرابة 100 نانوثانية. وسؤال التصميم هنا: هل بياناتي متجاورة في الذاكرة أم مبعثرة؟ وهذا يهم من يكتب محرك قاعدة بيانات أو مكتبة، ونادراً ما يهم من يكتب تطبيق ويب.
- **الميكروثواني (داخل الجهاز الواحد):** قراءة 4 كيلوبايت عشوائية من SSD بين عشرات ومئات الميكروثواني، والذهاب والعودة عبر TCP داخل الجهاز نفسه عشرات الميكروثواني، وطلب إلى Redis على الجهاز نفسه أو جهاز مجاور حوالي 100 ميكروثانية. والسؤال هنا: كم مرة أعبر حدود العملية Process أو الجهاز في الطلب الواحد؟
- **المللي ثواني (داخل مركز البيانات وبين المدن):** الذهاب والعودة داخل مركز البيانات نصف مللي ثانية، واستعلام مفهرس في قاعدة البيانات أقل من مللي ثانية، واستعلام بلا فهرس على جدول بمليون صف عشرات المللي ثواني، والاتصال بمدينة أخرى في القارة نفسها عشرات المللي ثواني. والسؤال: كم عملية متسلسلة في الطلب؟
- **مئات المللي ثواني والثواني (عبر القارات والمستخدم):** الذهاب والعودة بين القارات 150 إلى 300 مللي ثانية، وفتح اتصال HTTPS جديد مع شخص بعيد يحتاج عدة جولات من هذا النوع. والسؤال: هل يحتاج المستخدم أن يعبر المحيط ليرى الصفحة؟ وهذا سبب وجود شبكة توصيل المحتوى CDN التي شرحناها في [شبكة توصيل المحتوى CDN للمبتدئين](https://arabroot.io/articles/%D8%B4%D8%A8%D9%83%D8%A9-%D8%AA%D9%88%D8%B5%D9%8A%D9%84-%D8%A7%D9%84%D9%85%D8%AD%D8%AA%D9%88%D9%89-cdn-%D9%84%D9%84%D9%85%D8%A8%D8%AA%D8%AF%D8%A6%D9%8A%D9%86/).

وتحويل الأرقام إلى مقياس البشر يساعد على الإحساس بها، فإذا افترضنا أن قراءة L1 تأخذ ثانية واحدة بدل نانوثانية، فالقراءة من RAM تأخذ دقيقتين تقريباً، وقراءة عشوائية من SSD تأخذ يومين، والاستعلام بلا فهرس يأخذ أربع سنوات، والطلب إلى قارة أخرى يأخذ قرابة تسع سنوات. والصورة التالية تبين السلم بالأرقام التي قسناها في التجربة على جهاز واحد، ومعها هذا المقياس البشري:

![أعمدة أفقية بمحور لوغاريتمي للأزمنة المقاسة: L1 نانوثانية، وL2 3.6 نانوثانية، والذاكرة RAM 154 نانوثانية، وTCP داخل الجهاز 18.5 ميكروثانية، وRedis 169 ميكروثانية، وSSD 188 ميكروثانية، وPostgreSQL 340 ميكروثانية، وHTTP بين Containers قرابة مللي ثانية، وDNS 16 مللي ثانية، واستعلام بلا فهرس 139 مللي ثانية، وTCP إلى قارة أخرى 291 مللي ثانية، وبجانب كل منها الزمن لو كانت قراءة L1 ثانية واحدة](https://arabroot.io/content/images/2026/11/latency-numbers-01-ladder.webp)

كل درجة أبطأ من التي قبلها بعشرة إلى ألف ضعف، وبالمقياس البشري تصبح قارة أخرى قرابة تسع سنوات

وقد يتساءل البعض: إذا كان تطبيق الويب يعيش في طبقة المللي ثواني، فلماذا يهمني الفرق بين L1 وRAM؟ والإجابة أنه لا يهمك في أغلب الأيام، ولكن الطريقة نفسها تهمك في كل يوم: كل انتقال إلى الطبقة التالية تضرب الزمن في مئة أو ألف، لذلك أول سؤال عند أي بطء هو «في أي طبقة يقضي الطلب وقته، وكم مرة يعبر الحدود بين الطبقات؟». والطلب الذي يرسل 200 استعلام صغير إلى قاعدة البيانات، وهي مشكلة N+1 المعروفة، لا يبطئ لأن كل استعلام بطيء، وإنما لأن 200 جولة ذهاب وعودة بنصف مللي ثانية تصبح 100 مللي ثانية.

## لماذا المتوسط Average لا يكفي؟ النسب المئوية Percentiles

شرحنا النسب المئوية في [اختبار الضغط Load Testing](https://arabroot.io/articles/%D8%A7%D8%AE%D8%AA%D8%A8%D8%A7%D8%B1-%D8%A7%D9%84%D8%A7%D8%AD%D9%85%D8%A7%D9%84-%D9%88%D8%A7%D9%84%D8%B6%D8%BA%D8%B7-load-%D9%88-stress-testing-%D9%84%D9%84%D9%85%D8%A8%D8%AA%D8%AF%D8%A6%D9%8A%D9%86/) وفي [مفاهيم المراقبة Observability](https://arabroot.io/articles/%D9%85%D9%81%D8%A7%D9%87%D9%8A%D9%85-%D8%A7%D9%84%D9%85%D8%B1%D8%A7%D9%82%D8%A8%D8%A9-observability-%D9%85%D9%86-%D8%A7%D9%84%D8%A7%D8%B4%D8%A7%D8%B1%D8%A9-%D8%A7%D9%84%D9%89-%D8%A7%D9%84%D8%AA%D9%86%D8%A8%D9%8A%D9%87/)، والفكرة باختصار أن p50 أو الوسيط Median هو الزمن الذي يكون نصف الطلبات أسرع منه، وأن p99 هو الزمن الذي يكون 99% من الطلبات أسرع منه، أي أن طلباً واحداً من كل مئة أبطأ منه. أما المتوسط فيجمع كل الأزمنة ويقسمها على عددها، فيخفي الطلبات البطيئة إذا كانت قليلة، ويتأثر بطلب واحد شاذ إذا كان العدد صغيراً.

والنقطة التي تهمنا في هذا المقال أن زمن الاستجابة ليس رقماً واحداً، وإنما توزيع Distribution له شكل غير متماثل: أغلب الطلبات قريبة من أقل زمن ممكن، ثم ذيل طويل إلى اليمين فيه طلبات أبطأ بعشرة أضعاف أو مئة ضعف. وأسباب الذيل كثيرة ومعروفة: جامع النفايات Garbage Collection يوقف العملية لحظة، أو مهمة خلفية على السيرفر تأخذ المعالج، أو القرص يكتب صفحات متسخة Dirty Pages دفعة واحدة، أو حزمة ضاعت في الشبكة فانتظر TCP مهلة إعادة الإرسال، أو سيرفر مجاور على الجهاز الافتراضي نفسه أخذ الذاكرة المخبئية. وكل هذه الأشياء نادرة على الطلب الواحد، ولكنها شبه مؤكدة إذا كان عندك ملايين الطلبات، وسوف ترى في التجربة أن أرقام كل العمليات، حتى قراءة Redis، لها p99.9 أكبر من الوسيط بعشرة أضعاف أو أكثر.

ولاحظ أن المستخدم لا يرى الطلب الواحد، وإنما يرى الصفحة، والصفحة الحديثة ترسل عشرات الطلبات، والطلب الواحد في الخلفية قد يستدعي عدة خدمات. فإذا كانت الصفحة ترسل 40 طلباً، فاحتمال أن يقع أحدها على الأقل في أسوأ 1% هو 1 − 0.9940، أي حوالي 33%، وهذا يعني أن ثلث زيارات المستخدم ترى زمن p99 في مكان ما من الصفحة. لذلك ما تسميه «حالة نادرة» في رسم الخدمة الواحدة هو حالة يومية في تجربة المستخدم.

## ذيل التوزيع Tail Latency: ماذا تقول ورقة The Tail at Scale؟

في سنة 2013 نشر Jeff Dean وLuiz André Barroso من Google ورقة قصيرة في مجلة Communications of the ACM بعنوان [The Tail at Scale](https://research.google/pubs/the-tail-at-scale/?ref=arabroot.io)، وهي من أكثر الأوراق التي يقتبسها مهندسو الأنظمة. وفكرتها الأساسية أن الخدمة الكبيرة توزع الطلب الواحد على عدد كبير من السيرفرات، مثل محرك بحث يسأل مئات الأجزاء Shards من الفهرس في الوقت نفسه، ثم ينتظر كل الردود ليجمعها، وهذا النمط يسمى التوزيع والتجميع Fan-out. والطلب في هذا النمط بطيء بقدر أبطأ رد، لذلك ذيل السيرفر الواحد يصبح هو الحالة العادية للطلب كله.

والمثال الذي ذكرته الورقة: إذا كان كل سيرفر يرد عادة في 10 مللي ثوان، ولكن واحداً من كل مئة رد يأخذ ثانية كاملة، فالطلب الذي يسأل سيرفراً واحداً يكون بطيئاً مرة من كل مئة، أما الطلب الذي يسأل مئة سيرفر فيكون بطيئاً في 63% من الحالات، لأن احتمال أن تكون كل الردود المئة سريعة هو 0.99100، أي حوالي 37% فقط. وسوف نعيد هذه التجربة بأرقام حقيقية في المختبر، ونرى النسبة تخرج قريبة جداً من الحساب.

والورقة لا تقول «اجعل كل سيرفر سريعاً دائماً»، لأن ذلك مستحيل عملياً، وإنما تقترح أن تبني نظاماً يتحمل الذيل Tail-tolerant، كما تبني الأنظمة التي تتحمل أعطال الأجهزة. ومن الأساليب التي ذكرتها:

- **الطلب الاحتياطي Hedged Request:** ترسل الطلب إلى نسخة، فإذا لم يصل الرد خلال زمن p95 المعتاد ترسله إلى نسخة ثانية وتأخذ أول رد. وذكرت الورقة مثالاً على 1,000 مفتاح موزعة على 100 سيرفر نزل فيه p99.9 من 1,800 مللي ثانية إلى 74 مللي ثانية، مقابل زيادة 2% فقط في عدد الطلبات.
- **الطلب المربوط Tied Request:** ترسل الطلب إلى نسختين معاً، وكل نسخة تخبر الأخرى عندما تبدأ بتنفيذه فتلغيه الثانية، حتى لا يتكرر العمل.
- **تقسيم العمل إلى أجزاء صغيرة Micro-partitioning:** بدل جزء واحد كبير على كل سيرفر، توزع عشرات الأجزاء الصغيرة، فتستطيع أن تنقل جزءاً من السيرفر البطيء دون أن تنقل كل شيء.
- **إخراج السيرفر البطيء مؤقتاً Probation:** إذا لاحظت أن نسخة أبطأ من غيرها باستمرار أوقف إرسال الطلبات إليها، واستمر في فحصها حتى تعود.
- **نتيجة جيدة بما يكفي Good Enough:** في البحث مثلاً يكفي أن ترد من 99% من الأجزاء، بدل انتظار الجزء الأخير.

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

![رسم لنسبة الطلبات البطيئة مقابل عدد الطلبات المتوازية: الخط المحسوب 1 ناقص 0.99 أس N، والنقاط المقاسة 1% و7% و47.5% و66% عند 1 و10 و50 و100](https://arabroot.io/content/images/2026/11/latency-numbers-02-tail-at-scale.webp)

ما قسناه يتبع الحساب: مع 100 خدمة صار الذيل هو الحالة العادية

## قانون Little's Law: كم طلباً معلقاً في نظامك الآن؟

في سنة 1961 نشر John Little برهاناً لعلاقة بسيطة إلى درجة أن كثيرين يظنونها بديهية، وتقول إن متوسط عدد العناصر داخل أي نظام مستقر يساوي معدل وصولها مضروباً في متوسط الوقت الذي يقضيه كل عنصر داخله، أي:

```text
L = λ × W

L  متوسط عدد الطلبات داخل النظام (قيد الخدمة أو في الانتظار)
λ  معدل الوصول (طلب في الثانية)، وهو الإنتاجية في النظام المستقر
W  متوسط الزمن الذي يقضيه الطلب داخل النظام (ثانية)
```

وقوة هذا القانون، كما يشرح Little نفسه في [الفصل الذي كتبه مع Stephen Graves](https://web.mit.edu/sgraves/www/papers/Little%27s%20Law-Published.pdf?ref=arabroot.io) بعد خمسين سنة من البرهان، أنه لا يفترض شيئاً عن توزيع الأزمنة ولا عن ترتيب الخدمة، فهو يصح على مطعم أو مستودع أو سيرفر ويب أو مجمع اتصالات Connection Pool. والشرط الوحيد أن يكون النظام مستقراً، أي أن ما يخرج منه على المدى الطويل يساوي ما يدخله.

ولنأخذ أمثلة عملية من يوم المطور:

- **كم Worker تحتاج؟** خدمة يصلها 200 طلب في الثانية، والطلب يأخذ 50 مللي ثانية من العمل، إذن L = 200 × 0.05 = 10، أي أن هناك عشرة طلبات قيد الخدمة في المتوسط، فإذا كان عندك 8 عمال Workers فقط فالطلبات سوف تتجمع في الطابور ولن يستقر النظام.
- **كم اتصالاً بقاعدة البيانات؟** التطبيق يرسل 1,000 استعلام في الثانية، والاستعلام يحجز الاتصال 2 مللي ثانية، إذن يحتاج قرابة اتصالين مشغولين في المتوسط، فمجمع اتصالات بعشرين اتصالاً أكثر من كاف، والاتصالات الكثيرة لن تسرع شيئاً. وقد شرحنا هذا الجانب في [تجميع الاتصالات Connection Pooling](https://arabroot.io/articles/%D8%AA%D8%AC%D9%85%D9%8A%D8%B9-%D8%A7%D9%84%D8%A7%D8%AA%D8%B5%D8%A7%D9%84%D8%A7%D8%AA-connection-pooling-%D9%84%D9%84%D9%85%D8%A8%D8%AA%D8%AF%D8%A6%D9%8A%D9%86/).
- **ما أقصى إنتاجية ممكنة؟** القانون يعمل في الاتجاه الآخر أيضاً: إذا كان عندك 4 Workers والطلب يأخذ 10 مللي ثوان، فأقصى إنتاجية هي 4 ÷ 0.01 = 400 طلب في الثانية، وأي معدل وصول أعلى من ذلك يعني طابوراً ينمو بلا توقف.
- **القرص أيضاً:** عدد عمليات القرص في الثانية IOPS يساوي عدد الطلبات المعلقة Queue Depth مقسوماً على زمن العملية، لذلك القرص الذي يعطي 5,000 عملية بطلب واحد معلق قد يعطي 30,000 بأربعة وستين طلباً معلقاً، كما سوف نقيس.

### لماذا يرتفع الزمن فجأة قرب 100%؟ الاستخدام Utilization

قانون Little يخبرك بالعلاقة، ولكنه لا يخبرك متى يبدأ الانتظار، وهنا يأتي دور نظرية الطوابير Queueing Theory. والنتيجة الأشهر منها، لطابور واحد وسيرفر واحد ووصول عشوائي، أن متوسط الزمن داخل النظام يساوي زمن الخدمة مقسوماً على (1 − ρ)، حيث ρ هو الاستخدام Utilization، أي نسبة الوقت الذي يكون فيه السيرفر مشغولاً. فإذا كان الاستخدام 50% تضاعف الزمن، وإذا كان 90% صار عشرة أضعاف، وإذا كان 99% صار مئة ضعف. وهذا يفسر لماذا يقول لك فريق التشغيل إن السيرفر «يعمل بشكل ممتاز عند 70% ثم ينهار فجأة عند 90%»: لم يتغير زمن الخدمة، وإنما ظهر الطابور.

والقاعدة العملية التي تخرج من هذا أن لا تخطط لتشغيل أي مورد قريباً من 100% إذا كان زمن الاستجابة يهمك، واترك هامشاً يمتص الارتفاعات المفاجئة، وراقب التشبع Saturation، أي طول الطابور، وليس الاستخدام فقط، وهذا ما يسميه Brendan Gregg طريقة [USE](https://www.brendangregg.com/usemethod.html?ref=arabroot.io): الاستخدام والتشبع والأخطاء لكل مورد. والصورة التالية تبين العلاقة بين الثلاثة:

![قانون Little: L يساوي λ ضرب W مع مثال 200 طلب في الثانية ضرب 0.05 ثانية يساوي 10، وبجانبه منحنى الزمن مقسوماً على زمن الخدمة مقابل الاستخدام، ضعفان عند 50% وعشرة أضعاف عند 90%](https://arabroot.io/content/images/2026/11/latency-numbers-03-littles-law.webp)

القانون يربط الزمن بالإنتاجية، والمنحنى يبين لماذا يظهر الطابور فجأة قرب 100%

## التقدير السريع: صفحة «طلباتي» قبل أن تكتبها

لنعد الآن إلى صفحة «طلباتي» من البداية، ونقدر زمنها على الورق بالأرقام التي سوف نقيسها في التجربة، قبل أن نكتب سطراً من الكود. والافتراضات: التطبيق وقاعدة البيانات وRedis في مركز البيانات نفسه، وشركة الشحن في قارة أخرى، والصفحة تعرض 20 طلباً.

| الخطوة                                    | التصميم الأول (متسلسل)            | الزمن التقريبي              |
| ----------------------------------------- | --------------------------------- | --------------------------- |
| التحقق من الجلسة عبر HTTP إلى خدمة الدخول | طلب واحد                          | حوالي 1 مللي ثانية          |
| آخر 20 طلباً من PostgreSQL بفهرس          | استعلام واحد                      | أقل من 1 مللي ثانية         |
| اسم المنتج وصورته لكل طلب                 | 20 استعلاماً منفصلاً (N+1)        | 20 × 0.25 = 5 مللي ثوان     |
| حالة الشحنة من شركة الشحن                 | 20 طلب HTTPS متسلسل إلى قارة أخرى | 20 × 200 = 4,000 مللي ثانية |
| المجموع                                   |                                   | حوالي 4 ثوان                |

وهذا هو الرقم الذي اشتكى منه العميل، والحساب يبين فوراً أن الاستعلامات ليست المشكلة، فهي 6 مللي ثوان من 4 ثوان، وأن المشكلة كلها في 20 جولة متسلسلة عبر المحيط. وتحسين قاعدة البيانات هنا وقت ضائع، وأمامك ثلاثة خيارات بالترتيب:

1. **التوازي Parallelism:** ترسل الطلبات العشرين معاً، فيصبح الزمن زمن أبطأ طلب، أي قرابة 200 مللي ثانية في الحالة العادية. ولكن تذكر درس الذيل: إذا كان p99 لواجهة الشحن ثانيتين، فاحتمال أن يكون أحد الطلبات العشرين في هذا الذيل حوالي 18%، أي أن صفحة من كل ست صفحات تأخذ ثانيتين.
2. **التخزين المؤقت Caching:** حالة الشحنة لا تتغير كل ثانية، فتحفظها في Redis لخمس دقائق، وتصبح أغلب الطلبات 0.1 مللي ثانية بدل 200\. وقد شرحنا أنماط ذلك ومشكلاته في [التخزين المؤقت Caching بالتفصيل](https://arabroot.io/articles/%D8%A7%D9%84%D8%AA%D8%AE%D8%B2%D9%8A%D9%86-%D8%A7%D9%84%D9%85%D8%A4%D9%82%D8%AA-caching-%D8%A7%D9%84%D8%A7%D8%B3%D8%AA%D8%B1%D8%A7%D8%AA%D9%8A%D8%AC%D9%8A%D8%A7%D8%AA-%D9%88%D8%A7%D9%84%D8%A7%D8%A8%D8%B7%D8%A7%D9%84/).
3. **إخراج العمل من الطلب:** بدل أن تسأل شركة الشحن عند فتح الصفحة، تطلب منها أن ترسل إليك التحديث عندما يتغير عبر Webhook، أو تحدث الحالات دورياً بمهمة خلفية Background Job، فلا تنتظر الصفحة أي طرف خارجي. وهذا موضوع مقالين لاحقين في خارطة الطريق.

والجزء الثاني من التقدير هو السعة. لنفرض أن الصفحة بعد التحسين تأخذ 30 مللي ثانية من وقت Worker في المتوسط، وأن الذروة 300 فتح للصفحة في الثانية، فقانون Little يقول إن هناك 300 × 0.03 = 9 طلبات قيد الخدمة في المتوسط، وإذا أردت أن يبقى الاستخدام قرب 60% حتى لا يظهر الطابور فأنت تحتاج قرابة 15 Worker. ولو بقي التصميم الأول بأربع ثوان لكان الرقم 300 × 4 = 1,200 طلب معلق، وهذا لا يحتمله أي سيرفر عادي، وهذا هو الدرس الثاني: زمن الاستجابة الطويل لا يزعج المستخدم فقط، وإنما يستهلك السعة أيضاً، لأن كل طلب ينتظر يحجز Worker واتصالاً وذاكرة طوال انتظاره.

![ثلاثة تصاميم لصفحة طلباتي: عشرون طلباً متسلسلاً إلى شركة الشحن بقرابة 4 ثوان، ثم بالتوازي بقرابة 200 مللي ثانية مع ثانيتين في 18% من الصفحات، ثم من التخزين المؤقت بقرابة 10 مللي ثوان](https://arabroot.io/content/images/2026/11/latency-numbers-04-estimation.webp)

التقدير على الورق يبين أن المشكلة في الرحلات البعيدة المتسلسلة وليس في الاستعلامات

## تجربة عملية Lab: نقيس الأرقام على جهاز واحد

الجداول المنشورة مفيدة للإحساس بالأرقام، ولكن الرقم الذي تبني عليه قرارك هو الرقم الذي قسته على أجهزتك. وفي هذه التجربة نقيس كل درجة في السلم على جهاز واحد: معالج Intel Core i7-7700K فيه أربع أنوية بثمانية خيوط، وذاكرة مخبئية L1 بحجم 32 كيلوبايت وL2 بحجم 256 كيلوبايت وL3 بحجم 8 ميجابايت، وكل شيء يعمل داخل Containers. ثم نتحقق من قانون Little بأداة k6، ونعيد تجربة ورقة The Tail at Scale. وكل الملفات في مجلد `lab` مع المقال.

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

### التجهيز Setup

خمس خدمات في ملف Compose واحد: Redis، وPostgreSQL، وخدمة `api` بأربعة عمال من نوع sync في gunicorn، وخدمة `leaf` وأختها `leaf0` بعمال يستخدمون الخيوط Threads لتجربة الذيل، وContainer اسمه `bench` فيه أدوات القياس:

```yaml
name: sw3-lat
services:
  redis:
    image: redis:8-alpine
  pg:
    image: postgres:18-alpine
    environment:
      POSTGRES_PASSWORD: lab
  api:          # 4 sync workers by default: at most 4 requests in service at once
    build: { context: ., dockerfile: Dockerfile.api }
    image: sw3-lat-api:1
    command: gunicorn -w ${API_WORKERS:-4} -b 0.0.0.0:8000 --backlog 2048 app:app
  leaf:         # many threads: no queueing, only the slow tail (1% of calls take 1.5 s)
    image: sw3-lat-api:1
    command: gunicorn -k gthread -w 4 --threads 64 -b 0.0.0.0:8000 app:app
  leaf0:        # the same service without the slow tail, to measure the fan-out cost alone
    image: sw3-lat-api:1
    environment: { SLOW_PCT: "0" }
    command: gunicorn -k gthread -w 4 --threads 64 -b 0.0.0.0:8000 app:app
  bench:
    build: .
    image: sw3-lat-bench:1
    command: sleep infinity
    volumes: [ "./:/lab", "fio-data:/data" ]
volumes:
  fio-data:
```

والتطبيق الذي تخدمه الثلاث نقاط بسيط عمداً، حتى نعرف بالضبط ما الذي نقيسه:

```python
# app.py: a tiny WSGI app with three endpoints for the measurements.
#   /ping  returns at once            (network + HTTP cost only)
#   /work  takes 10 ms of "work"      (to watch queueing as the arrival rate grows)
#   /leaf  takes 20 ms, but SLOW_PCT% of calls take 1500 ms (a slow tail: a GC pause, a cold cache, a busy disk)
import os, random, time

SLOW = float(os.environ.get("SLOW_PCT", "1")) / 100

def app(environ, start_response):
    path = environ.get("PATH_INFO", "/")
    if path == "/work":
        time.sleep(0.010)
    elif path == "/leaf":
        time.sleep(1.5 if random.random() < SLOW else 0.020)
    start_response("200 OK", [("Content-Type", "text/plain"), ("Content-Length", "2")])
    return [b"ok"]
```

وصورة `bench` مبنية على `debian:trixie-slim`، وفيها gcc وfio وdig وcurl وPython مع مكتبتي Redis وPostgreSQL من حزم Debian، ونترجم فيها برنامج قياس الذاكرة:

```dockerfile
FROM debian:trixie-slim
RUN apt-get update && apt-get install -y --no-install-recommends \
      gcc libc6-dev fio dnsutils curl ca-certificates python3 python3-redis python3-psycopg \
    && rm -rf /var/lib/apt/lists/*
WORKDIR /lab
COPY memlat.c .
RUN gcc -O2 -o /usr/local/bin/memlat memlat.c -lpthread
```

```bash
docker compose up -d --build
```

### الذاكرة المخبئية والذاكرة الرئيسية: سلسلة المؤشرات Pointer Chasing

قياس زمن قراءة الذاكرة أصعب مما يبدو، لأن المعالج الحديث ذكي: يقرأ مسبقاً Prefetch ما يتوقع أنك سوف تحتاجه، وينفذ عدة قراءات في الوقت نفسه إذا لم تعتمد إحداها على الأخرى. والطريقة المعروفة منذ أداة lmbench أن تبني سلسلة من العقد، كل عقدة في سطر ذاكرة Cache Line مستقل بحجم 64 بايتاً، وكل عقدة تشير إلى التالية بترتيب عشوائي، ثم تتبع المؤشرات. فكل قراءة تعتمد على نتيجة التي قبلها، ولا يستطيع المعالج أن يخمن العنوان التالي، فيصبح الزمن لكل خطوة هو زمن الطبقة التي تحمل البيانات. ثم نكرر ذلك بأحجام مختلفة: إذا كان حجم السلسلة 16 كيلوبايت فهي كلها في L1، وإذا كان 256 ميجابايت فهي في الذاكرة الرئيسية:

```c
// memlat.c: memory latency by pointer chasing, plus 1 MB sequential read and an uncontended mutex.
// Build: gcc -O2 -o memlat memlat.c -lpthread    Run: ./memlat
#include <pthread.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#define LINE 64                       // one node per cache line
typedef struct node { struct node *next; char pad[LINE - sizeof(void *)]; } node;

static double now_ns(void) {
    struct timespec t; clock_gettime(CLOCK_MONOTONIC, &t);
    return t.tv_sec * 1e9 + t.tv_nsec;
}

// Each load depends on the previous one, so the CPU cannot overlap them:
// the time per step is the latency of the level that holds the working set.
static double chase(size_t bytes, size_t steps) {
    size_t n = bytes / LINE;
    node *a = aligned_alloc(4096, n * sizeof(node));
    size_t *perm = malloc(n * sizeof(size_t));
    for (size_t i = 0; i < n; i++) perm[i] = i;
    for (size_t i = n - 1; i > 0; i--) {              // random order defeats the prefetcher
        size_t j = (size_t)rand() % (i + 1), t = perm[i]; perm[i] = perm[j]; perm[j] = t;
    }
    for (size_t i = 0; i < n; i++) a[perm[i]].next = &a[perm[(i + 1) % n]];
    node *p = &a[perm[0]];
    for (size_t i = 0; i < n; i++) p = p->next;       // warm up
    double t0 = now_ns();
    for (size_t i = 0; i < steps; i++) p = p->next;
    double ns = (now_ns() - t0) / steps;
    if (p == NULL) puts("");                           // keep p alive
    free(perm); free(a);
    return ns;
}

static double seq_read_1mb(void) {
    size_t n = 1 << 20; uint64_t *buf = malloc(n); memset(buf, 1, n);
    volatile uint64_t sum = 0; int reps = 2000;
    double t0 = now_ns();
    for (int r = 0; r < reps; r++) { uint64_t s = 0; for (size_t i = 0; i < n / 8; i++) s += buf[i]; sum += s; }
    double ns = (now_ns() - t0) / reps;
    free(buf); return ns;
}

static double mutex_pair(void) {
    pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER; int reps = 10000000;
    double t0 = now_ns();
    for (int i = 0; i < reps; i++) { pthread_mutex_lock(&m); pthread_mutex_unlock(&m); }
    return (now_ns() - t0) / reps;
}

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

int main(void) {
    srand(42);
    size_t kb[] = {16, 24, 64, 128, 192, 512, 1024, 2048, 4096, 6144, 16384, 65536, 262144};
    printf("%-12s %8s %8s %8s\n", "working_set", "min_ns", "med_ns", "max_ns");
    for (size_t i = 0; i < sizeof kb / sizeof kb[0]; i++) {
        double r[7];                        // 7 runs: other programs share the L3 cache and the RAM
        for (int k = 0; k < 7; k++) r[k] = chase(kb[i] * 1024, 5000000);
        qsort(r, 7, sizeof r[0], cmp);
        if (kb[i] >= 1024) printf("%7zu MB   %8.2f %8.2f %8.2f\n", kb[i] / 1024, r[0], r[3], r[6]);
        else               printf("%7zu KB   %8.2f %8.2f %8.2f\n", kb[i], r[0], r[3], r[6]);
    }
    printf("seq_read_1MB_us   %8.1f\n", seq_read_1mb() / 1000);
    printf("mutex_lock_unlock_ns %5.1f\n", mutex_pair());
    return 0;
}
```

```bash
docker compose exec bench memlat
```

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

```text
working_set    min_ns   med_ns   max_ns
     16 KB       1.01     1.04     1.15
     24 KB       1.11     1.37     2.36
     64 KB       3.41     3.60     3.69
    128 KB       3.31     4.66     7.54
    192 KB       7.43     9.40    12.29
    512 KB      12.58    14.43    18.91
      1 MB      15.96    38.00    67.94
      2 MB      42.08    57.28   118.40
      4 MB      75.82   133.74   239.76
      6 MB     106.43   120.55   146.12
     16 MB     115.69   153.72   211.51
     64 MB     119.40   197.63   312.92
    256 MB     195.88   328.14   624.22
seq_read_1MB_us       85.4
mutex_lock_unlock_ns  30.4
```

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

- **حتى 24 كيلوبايت حوالي نانوثانية واحدة:** وهذا L1، أي أربع دورات تقريباً لمعالج يعمل بسرعة 4.2 جيجاهرتز.
- **من 64 إلى 128 كيلوبايت حوالي 3.5 نانوثانية:** البيانات خرجت من L1 ودخلت L2 الذي حجمه 256 كيلوبايت.
- **من 512 كيلوبايت إلى 2 ميجابايت بين 12 و57 نانوثانية:** هذه منطقة L3، ولاحظ أن الفرق بين أقل قيمة والوسيط كبير هنا تحديداً، وسوف نعود إلى ذلك بعد قليل.
- **من 16 ميجابايت فما فوق بين 115 و330 نانوثانية:** البيانات في الذاكرة الرئيسية، ومعها أخطاء جدول ترجمة العناوين TLB، لأن كل قراءة عشوائية في 256 ميجابايت تقع غالباً في صفحة ذاكرة مختلفة.
- **قراءة 1 ميجابايت متتالية في 85 ميكروثانية:** أسرع بكثير مما يوحي به رقم 100 نانوثانية للقراءة الواحدة، لأن القراءة المتتالية يتوقعها المعالج ويجلبها مسبقاً، وهذا سبب أن المصفوفة المتجاورة أسرع من القائمة المترابطة Linked List حتى لو كان عدد العمليات واحداً.
- **قفل Mutex وفكه دون منافسة 30 نانوثانية:** قريب من رقم Dean البالغ 25 نانوثانية، ولكنه يرتفع كثيراً إذا تنافست عليه خيوط عدة.

والمشكلة التي واجهتنا هنا أن أول نسخة من البرنامج كانت تقيس كل حجم مرة واحدة، فأعطت في التشغيل الأول 133 نانوثانية لحجم 1 ميجابايت، وفي التشغيل الثاني بعد دقيقة 37 نانوثانية، أي أن الرقم نفسه تغير أربعة أضعاف دون أن نغير شيئاً. والسبب أن ذاكرة L3 مشتركة بين كل أنوية المعالج، وأي برنامج آخر يعمل على الجهاز يملؤها ببياناته فيطرد بياناتنا، بينما L1 وL2 خاصتان بكل نواة فلم تتأثرا. لذلك عدلنا البرنامج ليقيس كل حجم سبع مرات ويطبع الأقل والوسيط والأكثر، والأقل هو أقرب رقم لما يستطيعه العتاد، والوسيط هو ما سوف تراه في يوم عادي. وهذا هو الجار المزعج Noisy Neighbor بأبسط صوره، وهو نفسه ما يحدث في السيرفرات الافتراضية المشتركة.

### القرص SSD: القراءة العشوائية والمتتالية بأداة fio

أداة [fio](https://fio.readthedocs.io/en/latest/fio%5Fdoc.html?ref=arabroot.io) هي المعيار لقياس الأقراص، ونطلب منها قراءة 4 كيلوبايت عشوائية بطلب واحد معلق في كل لحظة، أي عمق طابور Queue Depth يساوي 1، مع `direct=1` حتى تتجاوز ذاكرة الصفحات المؤقتة Page Cache في Linux وتصل إلى القرص فعلاً، ثم قراءة متتالية بحجم 1 ميجابايت:

```ini
; fio-randread.ini: 4 KiB random reads, one at a time (queue depth 1), bypassing the page cache
[global]
filename=/data/fio.bin
size=2g
direct=1
ioengine=libaio
time_based=1
runtime=20

[randread-4k-qd1]
rw=randread
bs=4k
iodepth=1

[seqread-1m]
stonewall
rw=read
bs=1m
iodepth=1
```

```bash
docker compose exec bench fio fio-randread.ini
```

والمخرج مختصراً إلى الأسطر المهمة:

```text
randread-4k-qd1: (groupid=0, jobs=1): err= 0: pid=43: Wed Nov 18 10:21:29 2026
  read: IOPS=4377, BW=17.1MiB/s (17.9MB/s)(342MiB/20001msec)
    clat (usec): min=3, max=23223, avg=205.93, stdev=215.30
    clat percentiles (usec):
     |  1.00th=[  122],  5.00th=[  141], 10.00th=[  155], 20.00th=[  161],
     | 30.00th=[  172], 40.00th=[  182], 50.00th=[  188], 60.00th=[  196],
     | 70.00th=[  204], 80.00th=[  217], 90.00th=[  235], 95.00th=[  273],
     | 99.00th=[  594], 99.50th=[  791], 99.90th=[ 2089], 99.95th=[ 3818],
seqread-1m: (groupid=1, jobs=1): err= 0: pid=44: Wed Nov 18 10:21:29 2026
  read: IOPS=830, BW=831MiB/s (871MB/s)(16.2GiB/20002msec)
    clat (usec): min=10, max=108211, avg=1132.92, stdev=1199.53
    clat percentiles (usec):
     |  1.00th=[  775],  5.00th=[  865], 10.00th=[  906], 20.00th=[  955],
     | 30.00th=[  996], 40.00th=[ 1037], 50.00th=[ 1074], 60.00th=[ 1106],
     | 70.00th=[ 1156], 80.00th=[ 1205], 90.00th=[ 1287], 95.00th=[ 1418],
     | 99.00th=[ 1909], 99.50th=[ 2999], 99.90th=[ 9372], 99.95th=[15926],
```

القراءة العشوائية الواحدة وسيطها 188 ميكروثانية، وp99 هو 594 ميكروثانية، وp99.95 قرابة 4 مللي ثوان، أي عشرين ضعف الوسيط. والقراءة المتتالية لميجابايت كامل وسيطها 1.07 مللي ثانية بسرعة 831 ميجابايت في الثانية. والرقمان قريبان جداً من جدول Dean الذي يقول 150 ميكروثانية للقراءة العشوائية و1 مللي ثانية للميجابايت المتتالي، مع أن القرص هنا ملف افتراضي داخل WSL2 على Windows، أي أن بين fio والقرص الحقيقي طبقتين من الافتراضية.

والآن نطبق قانون Little على القرص نفسه: نكرر القراءة العشوائية بعمق طابور 1 ثم 4 ثم 16 ثم 64، والسكربت `fio-summary.py` يقسم عمق الطابور على متوسط الزمن في كل سطر ليقارن الناتج بعدد العمليات الذي قاسه fio:

```bash
docker compose exec bench sh -c "fio --output-format=json fio-qd.ini | python3 fio-summary.py"
```

```text
qd1   IOPS=   1369  mean=   725us  p50=   301us  p99=  9372us  | queue depth / mean =    1379 IOPS
qd4   IOPS=   3666  mean=  1088us  p50=   367us  p99= 15663us  | queue depth / mean =    3677 IOPS
qd16  IOPS=   4219  mean=  3789us  p50=   930us  p99= 39059us  | queue depth / mean =    4222 IOPS
qd64  IOPS=   4858  mean= 13172us  p50=  2802us  p99=105382us  | queue depth / mean =    4859 IOPS
```

العمود الأخير يطابق عمود IOPS في كل سطر تقريباً حتى آخر رقم، وهذا قانون Little بلا أي افتراض: عدد العمليات في الثانية يساوي عدد العمليات المعلقة مقسوماً على زمن العملية. ولكن لاحظ ما حدث في هذا التشغيل: IOPS ارتفعت من 1,369 إلى 3,666 عندما رفعنا العمق إلى 4، ثم توقفت تقريباً عند 4,000 إلى 5,000، بينما المتوسط ارتفع من 0.7 مللي ثانية إلى 13 مللي ثانية، وp99 وصل إلى 105 مللي ثوان. فالقرص وصل إلى سعته، لأن أعمالاً أخرى على الجهاز كانت تقرأ وتكتب في الوقت نفسه، وكل طلب إضافي في الطابور لم يزد الإنتاجية، وإنما زاد الانتظار فقط. وهذا هو منحنى الاستخدام الذي شرحناه في قسم قانون Little، مقاساً على قرص حقيقي. وفي تشغيل سابق في وقت أهدأ من اليوم وصلت الإنتاجية نفسها إلى قرابة 30,000 عملية في الثانية بعمق 64، أي أن السعة نفسها التي تخطط عليها قد تكون ستة أضعاف ما يتبقى لك في ساعة مزدحمة.

![أعمدة لقراءات القرص العشوائية بعمق طابور 1 و4 و16 و64: العمليات في الثانية 1369 و3666 و4219 و4858، والمتوسط 0.72 و1.09 و3.79 و13.17 مللي ثانية](https://arabroot.io/content/images/2026/11/latency-numbers-05-fio-qd.webp)

على قرص مشغول توقفت الإنتاجية وارتفع الانتظار، وقانون Little طابق كل سطر

### الشبكة وقواعد البيانات: من TCP المحلي إلى DNS

السكربت `netbench.py` يقيس كل عملية آلاف المرات، وكل عينة هي جولة ذهاب وعودة كاملة من داخل Python، ثم يطبع المتوسط والنسب المئوية والحد الأقصى بالدالة `report` من الملف `stats.py`:

```python
# netbench.py: round-trip latency of the operations an application does every day.
# Every sample is one complete round trip, timed with perf_counter_ns, in microseconds.
import http.client, random, socket, subprocess, sys, threading, time
import psycopg, redis
from stats import report

N = int(sys.argv[1]) if len(sys.argv) > 1 else 20000

def timed(fn, n):
    out = []
    for _ in range(n):
        t0 = time.perf_counter_ns(); fn(); out.append((time.perf_counter_ns() - t0) / 1000)
    return out

# 1) TCP round trip on 127.0.0.1 inside the same container (no network card at all)
def echo_server(sock):
    c, _ = sock.accept()
    c.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
    while (b := c.recv(64)):
        c.sendall(b)
srv = socket.socket(); srv.bind(("127.0.0.1", 0)); srv.listen()
threading.Thread(target=echo_server, args=(srv,), daemon=True).start()
cli = socket.create_connection(srv.getsockname()); cli.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
def tcp_rt(): cli.sendall(b"x"); cli.recv(64)
report("tcp_localhost_rtt", timed(tcp_rt, N))

# 2) HTTP GET to another container: one kept-alive connection, then a new TCP connection per request
#    (the "leaf" service uses gthread workers, which keep connections open; sync workers close them)
conn = http.client.HTTPConnection("leaf", 8000)
def http_keepalive(): conn.request("GET", "/ping"); conn.getresponse().read()
report("http_container_keepalive", timed(http_keepalive, N // 4))
def http_new():
    c = http.client.HTTPConnection("leaf", 8000); c.request("GET", "/ping"); c.getresponse().read(); c.close()
report("http_container_new_conn", timed(http_new, N // 4))

# 3) Redis GET of a small key
r = redis.Redis(host="redis"); r.set("user:42", "x" * 100)
report("redis_get", timed(lambda: r.get("user:42"), N))

# 4) PostgreSQL: one row by primary key, and the same table scanned without an index
pg = psycopg.connect("host=pg user=postgres password=lab", autocommit=True)
pg.execute("""CREATE TABLE IF NOT EXISTS items (id bigint PRIMARY KEY, sku text, price numeric);
              INSERT INTO items SELECT g, 'sku-' || g, g % 997 FROM generate_series(1, 1000000) g
              ON CONFLICT DO NOTHING; ANALYZE items;""")
cur = pg.cursor()
def pk(): cur.execute("SELECT price FROM items WHERE id = %s", (random.randint(1, 1000000),), prepare=True); cur.fetchone()
report("pg_select_by_pk", timed(pk, N))
def scan(): cur.execute("SELECT price FROM items WHERE sku = %s", (f"sku-{random.randint(1, 1000000)}",)); cur.fetchone()
report("pg_select_no_index", timed(scan, 50))

# 5) DNS: a container name through Docker's resolver, then a public name
report("dns_container_name", timed(lambda: socket.getaddrinfo("redis", 6379, type=socket.SOCK_STREAM), 2000))
report("dns_public_name", timed(lambda: socket.getaddrinfo("example.com", 443, type=socket.SOCK_STREAM), 200))
```

```bash
docker compose exec bench python3 netbench.py
```

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

```text
tcp_localhost_rtt          n=20000  mean=63.7us  p50=18.5us  p95=32.6us  p99=102.3us  p99.9=11.25ms  max=33.15ms
http_container_keepalive   n=5000  mean=2.70ms  p50=981.9us  p95=12.25ms  p99=26.68ms  p99.9=58.46ms  max=102.08ms
http_container_new_conn    n=5000  mean=3.84ms  p50=1.88ms  p95=9.10ms  p99=20.49ms  p99.9=55.46ms  max=1918.64ms
redis_get                  n=20000  mean=510.6us  p50=168.6us  p95=779.7us  p99=11.30ms  p99.9=23.52ms  max=40.64ms
pg_select_by_pk            n=20000  mean=756.8us  p50=340.2us  p95=2.46ms  p99=10.65ms  p99.9=15.79ms  max=27.68ms
pg_select_no_index         n=50  mean=158.92ms  p50=138.69ms  p95=249.15ms  p99=285.23ms  p99.9=285.23ms  max=285.23ms
dns_container_name         n=2000  mean=997.4us  p50=305.6us  p95=4.58ms  p99=14.83ms  p99.9=33.31ms  max=42.86ms
dns_public_name            n=200  mean=20.06ms  p50=15.89ms  p95=49.30ms  p99=86.28ms  p99.9=269.58ms  max=269.58ms
```

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

- **TCP داخل الجهاز 18.5 ميكروثانية:** بلا بطاقة شبكة أصلاً، والزمن كله في نواة Linux وفي Python نفسها، وهذا هو الحد الأدنى لأي اتصال بين عمليتين عبر TCP.
- **Redis GET بوسيط 169 ميكروثانية:** Redis نفسه ينفذ الأمر في ميكروثوان، والباقي جولة بين Containers عبر الشبكة الافتراضية في Docker ومكتبة العميل.
- **PostgreSQL بالمفتاح الأساسي 340 ميكروثانية، وبلا فهرس 139 مللي ثانية:** الاستعلام نفسه على الجدول نفسه بمليون صف، والفرق أربعمئة ضعف، وهو الفرق بين قراءة بضع صفحات من الفهرس ومسح الجدول كله. وقد شرحنا كيف تقرأ هذا الفرق في [الفهارس وقراءة EXPLAIN](https://arabroot.io/articles/%D8%A7%D9%84%D9%81%D9%87%D8%A7%D8%B1%D8%B3-indexes-%D9%88%D9%82%D8%B1%D8%A7%D8%A1%D8%A9-explain/).
- **HTTP بين Containers قرابة 1 مللي ثانية باتصال مفتوح و1.9 باتصال جديد:** فتح اتصال TCP جديد لكل طلب يضاعف الزمن تقريباً، ومع HTTPS يصبح الفرق أكبر لأن المصافحة Handshake تضيف جولات أخرى.
- **DNS لاسم Container داخلي 0.3 مللي ثانية، ولاسم عام 16 مللي ثانية:** كل طلب لا يحفظ نتيجة DNS يدفع هذا الثمن، والتطبيق الذي يحل الاسم في كل طلب HTTP خارجي يضيف هذا الزمن إلى كل طلب.
- **p99 أكبر من الوسيط بخمسين إلى ستين ضعفاً في Redis وPostgreSQL:** وهذا ما سوف نناقشه في القسم التالي.

### التشغيل نفسه في ثلاثة أوقات: الوسيط ثابت والذيل لا

شغلنا `netbench.py` ثلاث مرات خلال اليوم على الجهاز نفسه دون أي تغيير، والجدول التالي يقارن الوسيط وp99 في المرات الثلاث:

| العملية             | p50 في التشغيلات الثلاثة      | p99 في التشغيلات الثلاثة        |
| ------------------- | ----------------------------- | ------------------------------- |
| TCP داخل الجهاز     | 67 / 18.8 / 18.5 ميكروثانية   | 170 / 563 / 102 ميكروثانية      |
| Redis GET           | 123 / 157 / 169 ميكروثانية    | 0.35 / 10.03 / 11.30 مللي ثانية |
| PostgreSQL بالمفتاح | 242 / 348 / 340 ميكروثانية    | 0.77 / 11.47 / 10.65 مللي ثانية |
| PostgreSQL بلا فهرس | 63 / 90 / 139 مللي ثانية      | 125 / 183 / 285 مللي ثانية      |
| DNS لاسم داخلي      | 0.30 / 0.32 / 0.31 مللي ثانية | 0.67 / 4.82 / 14.83 مللي ثانية  |

الوسيط تغير في أغلب الصفوف بأقل من الضعف، أما p99 فتغير ثلاثين ضعفاً في Redis وPostgreSQL بين التشغيل الأول الهادئ والتشغيلين اللاحقين، والسبب الوحيد أن أعمالاً أخرى على الجهاز صارت تأخذ المعالج والقرص. والطلب البطيء هنا ليس طلباً «خاصاً»، وإنما طلب عادي جاء في اللحظة التي أخذ فيها برنامج آخر المعالج. وهذا ما تقصده ورقة The Tail at Scale بأسباب الذيل: الموارد المشتركة، وعمليات الخلفية، والطوابير على كل مستوى. والدرس العملي: إذا قست مرة واحدة في وقت هادئ وصممت على p99 الذي رأيته، فسوف يخيب ظنك في الإنتاج.

### مشكلة ظهرت في الطريق: الاتصال المفتوح لم يكن مفتوحاً

في التشغيل الأول كانت قياسات HTTP موجهة إلى خدمة `api`، وكانت النتيجة غريبة: الطلب «باتصال مفتوح» Keep-alive أخذ الوقت نفسه تقريباً الذي أخذه الطلب باتصال جديد، 1.80 مقابل 1.75 مللي ثانية. ولكي نفهم السبب طبعنا رأس `Connection` في الرد من الخدمتين:

```text
api Connection: close
api_reuse                 n=3000  mean=1.36ms  p50=1.24ms  p95=2.08ms  p99=3.90ms  p99.9=12.63ms  max=21.53ms
leaf Connection: keep-alive
leaf_reuse                n=3000  mean=523.4us  p50=474.1us  p95=845.0us  p99=1.14ms  p99.9=2.68ms  max=4.46ms
```

الخدمة `api` ترد بـ `Connection: close`، والسبب أن عمال sync في gunicorn لا يدعمون الاتصال المفتوح أصلاً، كما يذكر [توثيق تصميم gunicorn](https://gunicorn.org/design/?ref=arabroot.io)، فيغلقون الاتصال بعد كل رد، ومكتبة `http.client` تفتح اتصالاً جديداً في الطلب التالي دون أن تخبرك. أما `leaf` بعمال gthread فتبقي الاتصال مفتوحاً، والطلب عليها أسرع بمرتين ونصف. لذلك وجهنا قياسات HTTP في السكربت إلى `leaf`. وهذا خطأ تراه في الإنتاج أيضاً: خدمة داخلية تتحدث مع أخرى آلاف المرات في الثانية، وكل طلب يفتح اتصالاً جديداً لأن أحد الطرفين لا يدعم الاتصال المفتوح أو لأن العميل ينشئ كائناً جديداً لكل طلب، والزمن والمعالج يضيعان في المصافحات.

### الإنترنت: زمن فتح اتصال TCP إلى مناطق مختلفة

آخر درجة في السلم هي المسافة الجغرافية، ونقيسها بزمن فتح اتصال TCP، لأنه يساوي جولة ذهاب وعودة واحدة تقريباً، رسالة SYN ثم SYN-ACK، دون أن يتأثر بسرعة السيرفر في معالجة الطلب. والسكربت يحل الاسم مرة واحدة خارج القياس، ثم يفتح 20 اتصالاً إلى كل وجهة، والوجهات نقاط تخزين S3 العامة في مناطق مختلفة، لأن موقع كل منها معروف:

```python
# internet.py: TCP connect time (one round trip: SYN, SYN-ACK) to public endpoints in different regions.
import socket, sys, time
from stats import report

HOSTS = sys.argv[1:] or ["8.8.8.8", "s3.me-central-1.amazonaws.com", "s3.eu-central-1.amazonaws.com",
                         "s3.us-east-1.amazonaws.com", "s3.us-west-2.amazonaws.com", "s3.ap-southeast-1.amazonaws.com"]
for host in HOSTS:
    ip = socket.getaddrinfo(host, 443, socket.AF_INET, socket.SOCK_STREAM)[0][4][0]  # resolve once, outside the timing
    xs = []
    for _ in range(20):
        t0 = time.perf_counter_ns()
        s = socket.create_connection((ip, 443), timeout=5)
        xs.append((time.perf_counter_ns() - t0) / 1000); s.close(); time.sleep(0.2)
    report(host, xs)
```

```text
8.8.8.8                    n=20  mean=59.38ms  p50=47.57ms  p95=118.84ms  p99=121.47ms  p99.9=121.47ms  max=121.47ms
s3.me-central-1.amazonaws.com n=20  mean=50.91ms  p50=43.09ms  p95=67.85ms  p99=124.66ms  p99.9=124.66ms  max=124.66ms
s3.eu-central-1.amazonaws.com n=20  mean=153.80ms  p50=139.37ms  p95=204.02ms  p99=433.18ms  p99.9=433.18ms  max=433.18ms
s3.us-east-1.amazonaws.com n=20  mean=213.66ms  p50=205.56ms  p95=282.35ms  p99=288.21ms  p99.9=288.21ms  max=288.21ms
s3.us-west-2.amazonaws.com n=20  mean=317.53ms  p50=290.99ms  p95=412.66ms  p99=583.97ms  p99.9=583.97ms  max=583.97ms
s3.ap-southeast-1.amazonaws.com n=20  mean=249.14ms  p50=242.80ms  p95=290.37ms  p99=291.54ms  p99.9=291.54ms  max=291.54ms
```

الوسيط يرتفع مع المسافة كما تتوقع: قرابة 43 مللي ثانية إلى منطقة الإمارات، و139 إلى فرانكفورت، و206 إلى فرجينيا، و243 إلى سنغافورة، و291 إلى أوريغون. ولاحظ أن هذه الأرقام أكبر بكثير من الحد الفيزيائي، فالضوء في الألياف يقطع قرابة 200 كيلومتر في المللي ثانية، أي أن جولة ذهاب وعودة إلى مدينة تبعد 3,000 كيلومتر تحتاج 30 مللي ثانية على الأقل في خط مستقيم، والباقي هو مسار الكابلات الفعلي والموجهات Routers على الطريق. ورقمك أنت سوف يختلف حسب مكانك ومزود الإنترنت، فشغل السكربت نفسه من سيرفرك قبل أن تختار منطقة الاستضافة. والدرس الأهم أن طلباً واحداً إلى قارة أخرى يأخذ وقتاً أطول من مئات الاستعلامات المفهرسة في قاعدة بياناتك.

### قانون Little تحت الضغط: k6 بمعدل وصول ثابت

الآن نختبر الخدمة `api`: أربعة عمال sync، وكل طلب على `/work` ينام 10 مللي ثوان، فالسعة النظرية 4 ÷ 0.010 = 400 طلب في الثانية، والسعة الحقيقية أقل لأن لكل طلب كلفة إضافية في Python وgunicorn. ونستخدم في k6 المنفذ [constant-arrival-rate](https://grafana.com/docs/k6/latest/using-k6/scenarios/executors/constant-arrival-rate/?ref=arabroot.io)، وهو نموذج مفتوح Open Model يرسل الطلبات بمعدل ثابت سواء انتهت الطلبات السابقة أم لا، كما يفعل المستخدمون الحقيقيون، وقد شرحنا الفرق بينه وبين النموذج المغلق في مقال اختبار الضغط:

```javascript
// littles.js: open-model load (a fixed arrival rate) on /work, which takes 10 ms with 4 workers.
// k6 run -e RATE=200 littles.js
import http from 'k6/http';

const RATE = Number(__ENV.RATE || 100);

export const options = {
  scenarios: {
    open: {
      executor: 'constant-arrival-rate',   // new requests arrive at RATE/s whether the old ones finished or not
      rate: RATE, timeUnit: '1s', duration: '30s',
      preAllocatedVUs: 50, maxVUs: 400,
    },
  },
  summaryTrendStats: ['avg', 'med', 'p(95)', 'p(99)', 'max'],
};

export default function () {
  http.get('http://api:8000/work', { timeout: '60s' });
}
```

```bash
for r in 100 200 300 340 370 400 450; do
  echo "== RATE=$r"
  docker run --rm --network sw3-lat_default -v "$PWD:/lab" grafana/k6:1.8.3 run -q -e RATE=$r /lab/littles.js
done
```

والمخرج مختصراً إلى الأسطر المهمة:

```text
== RATE=100
    http_req_duration..............: avg=13.51ms med=11.18ms p(95)=24.85ms p(99)=34.11ms max=60.64ms
    http_reqs......................: 3001   100.000164/s
    vus_max........................: 50     min=50        max=50
== RATE=200
    http_req_duration..............: avg=11.47ms med=11ms    p(95)=12.38ms p(99)=24.27ms max=64.95ms
    http_reqs......................: 6000   199.961188/s
    vus_max........................: 50     min=50        max=50
== RATE=300
    http_req_duration..............: avg=19.07ms med=11.07ms p(95)=59.02ms p(99)=72.37ms max=88.28ms
    http_reqs......................: 9000   299.922174/s
    vus_max........................: 50     min=50        max=50
== RATE=340
    http_req_duration..............: avg=1.34s med=1.52s p(95)=1.99s p(99)=2.05s max=2.09s
    http_reqs......................: 7553   240.756383/s
    dropped_iterations.............: 2647   84.374705/s
    vus_max........................: 400    min=50        max=400
== RATE=370
    http_req_duration..............: avg=1.21s med=1.18s p(95)=1.83s p(99)=1.9s max=1.96s
    http_reqs......................: 8803   282.934601/s
    dropped_iterations.............: 2298   73.859334/s
    vus_max........................: 400    min=74        max=400
== RATE=400
    http_req_duration..............: avg=887.41ms med=1.1s p(95)=1.21s p(99)=1.29s max=1.31s
    http_reqs......................: 10703  344.124161/s
    dropped_iterations.............: 1297   41.701302/s
    vus_max........................: 400    min=61         max=400
== RATE=450
    http_req_duration..............: avg=1.07s med=1.15s p(95)=1.52s p(99)=1.57s max=1.61s
    http_reqs......................: 9949   319.845476/s
    dropped_iterations.............: 3551   114.159341/s
    vus_max........................: 400    min=71        max=400
```

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

- **حتى 200 طلب في الثانية:** الوسيط 11 مللي ثانية، أي زمن الخدمة نفسه تقريباً، ولا يوجد انتظار، وقانون Little يقول إن عدد الطلبات داخل الخدمة في المتوسط 200 × 0.01147 = 2.3، أي أقل من العمال الأربعة.
- **عند 300 طلب في الثانية:** الوسيط ما زال 11 مللي ثانية، ولكن p95 ارتفع إلى 59 مللي ثانية، فالطابور بدأ يظهر في الذيل، والعدد داخل الخدمة 300 × 0.01907 = 5.7، أي أكثر من العمال الأربعة، فهناك طلبات تنتظر دورها.
- **عند 340 طلب في الثانية:** انهيار كامل، والوسيط 1.52 ثانية بدل 11 مللي ثانية، أي 140 ضعفاً مقابل زيادة 13% فقط في المعدل، والإنتاجية الفعلية نزلت إلى 241 طلباً في الثانية، وk6 أسقط 2,647 طلباً لأنه وصل إلى حده الأقصى من المستخدمين الافتراضيين، 400.
- **بعد الانهيار يحكم القانون نفسه:** عند 400 طلب في الثانية كانت الإنتاجية 344 والمتوسط 0.887 ثانية، فالعدد داخل النظام 344 × 0.887 = 305، وهذا قريب من 400 مستخدم افتراضي هو كل ما سمح به k6، أي أن الطابور امتلأ إلى آخره، وكل طلب جديد ينتظر خلف ثلاثمئة طلب.

والسعة الحقيقية إذن بين 300 و340 طلباً في الثانية، وليست 400\. ولاحظ أن الانتقال من «ممتاز» إلى «منهار» حدث بين قراءتين متجاورتين، وهذا ما لا يظهر في رسم يعرض المتوسط كل خمس دقائق.

![رسم خطي لوغاريتمي لزمن الطلب مقابل معدل الوصول: الوسيط 11 مللي ثانية حتى 300 طلب في الثانية وp95 59 مللي ثانية عند 300، ثم قفزة إلى 1.5 ثانية عند 340 وما بعدها](https://arabroot.io/content/images/2026/11/latency-numbers-06-knee.webp)

الانتقال من ممتاز إلى منهار حدث بين قراءتين متجاورتين

### ماذا لو ضاعفنا العمال؟ What If

نعيد تشغيل الخدمة بثمانية عمال بدل أربعة، ونعيد المعدلين 300 و450:

```bash
API_WORKERS=8 docker compose up -d api
```

```text
== RATE=300
    http_req_duration..............: avg=40.3ms med=29.2ms  p(95)=113.06ms p(99)=148.96ms max=214.07ms
    http_reqs......................: 8987   299.032624/s
    dropped_iterations.............: 14     0.465835/s
    vus_max........................: 53     min=50        max=53
== RATE=450
    http_req_duration..............: avg=952.64ms med=1.04s p(95)=1.56s p(99)=1.64s max=1.77s
    http_reqs......................: 10080  333.984714/s
    dropped_iterations.............: 3417   113.216842/s
    vus_max........................: 400    min=72         max=400
```

عند 300 طلب في الثانية لم تعد الخدمة على الحافة، فالـ p95 صار 113 مللي ثانية والطلبات المسقطة 14 فقط، ولكن الوسيط ارتفع إلى 29 مللي ثانية بدل 11\. وعند 450 انهارت مرة ثانية، والإنتاجية توقفت عند 334 طلباً في الثانية، أي أقل بكثير من السعة النظرية الجديدة 800\. والسبب أن العمال ليسوا المورد الوحيد: ثمانية عمليات Python تتنافس الآن على المعالج نفسه الذي يشغل k6 وبقية الجهاز، فانتقل عنق الزجاجة Bottleneck من عدد العمال إلى المعالج. وهذا هو الدرس في كل تقدير بقانون Little: الرقم الذي تحصل عليه هو سعة مورد واحد، ويجب أن تحسب كل مورد في الطريق، العمال والمعالج والاتصالات بقاعدة البيانات والقرص، وأصغرها هو سعة النظام.

### The Tail at Scale بأرقام حقيقية: الطلب الذي ينتظر مئة خدمة

نعيد مثال الورقة: الخدمة `leaf` ترد عادة في 20 مللي ثانية، ولكن 1% من الطلبات تأخذ 1.5 ثانية، والخدمة `leaf0` هي نفسها بلا ذيل. والسكربت في k6 يمثل طلب مستخدم واحد يرسل N طلباً متوازياً بالدالة `http.batch` وينتظرها كلها، ويعد الجولات التي تجاوزت ثانية واحدة، أي التي انتظرت طلباً بطيئاً واحداً على الأقل:

```javascript
// fanout.js: each iteration is one user request that calls /leaf n times in parallel and waits for all.
// k6 run -e N=10 -e HOST=leaf fanout.js
import http from 'k6/http';
import { Rate, Trend } from 'k6/metrics';

const N = Number(__ENV.N || 10), HOST = __ENV.HOST || 'leaf';
const round = new Trend('fanout_round', true);
const slow = new Rate('slow_rounds');            // rounds that waited for at least one slow call

export const options = {
  scenarios: { fan: { executor: 'per-vu-iterations', vus: 1, iterations: 200 } },
  batch: 100, batchPerHost: 100,
  summaryTrendStats: ['med', 'p(95)', 'p(99)', 'max'],
};

export default function () {
  const reqs = Array.from({ length: N }, () => ['GET', `http://${HOST}:8000/leaf`]);
  const t0 = Date.now();
  http.batch(reqs);
  const ms = Date.now() - t0;
  round.add(ms);
  slow.add(ms > 1000);
}
```

```bash
for h in leaf0 leaf; do for n in 1 10 50 100; do
  echo "== HOST=$h N=$n"
  docker run --rm --network sw3-lat_default -v "$PWD:/lab" grafana/k6:1.8.3 run -q -e N=$n -e HOST=$h /lab/fanout.js
done; done
```

```text
== HOST=leaf0 N=1
    fanout_round...................: med=22ms    p(95)=33.04ms p(99)=38.02ms max=337ms
    slow_rounds....................: 0.00% 0 out of 200
== HOST=leaf0 N=10
    fanout_round...................: med=34ms    p(95)=52.04ms p(99)=61.18ms max=443ms
    slow_rounds....................: 0.00%  0 out of 200
== HOST=leaf0 N=50
    fanout_round...................: med=58ms    p(95)=95.04ms p(99)=108.13ms max=126ms
    slow_rounds....................: 0.00%  0 out of 200
== HOST=leaf0 N=100
    fanout_round...................: med=119ms    p(95)=192.09ms p(99)=214.13ms max=287ms
    slow_rounds....................: 0.00%  0 out of 200
== HOST=leaf N=1
    fanout_round...................: med=22ms    p(95)=38.14ms p(99)=73.41ms max=1.5s
    slow_rounds....................: 1.00% 2 out of 200
== HOST=leaf N=10
    fanout_round...................: med=23ms    p(95)=1.5s    p(99)=1.5s    max=1.52s
    slow_rounds....................: 7.00%  14 out of 200
== HOST=leaf N=50
    fanout_round...................: med=142ms    p(95)=1.54s   p(99)=1.58s max=1.59s
    slow_rounds....................: 47.50% 95 out of 200
== HOST=leaf N=100
    fanout_round...................: med=1.5s    p(95)=1.56s  p(99)=1.63s max=1.65s
    slow_rounds....................: 66.00% 132 out of 200
```

النسب التي قسناها 1% ثم 7% ثم 47.5% ثم 66%، والحساب يقول 1% ثم 9.6% ثم 39.5% ثم 63.4%، وهذا تطابق جيد لعينة من 200 جولة. ومع 100 طلب متوازي صار الوسيط نفسه 1.5 ثانية، أي أن «الحالة النادرة» للخدمة الواحدة صارت الحالة العادية للمستخدم. أما `leaf0` بلا ذيل فلم تتجاوز أي جولة ثانية واحدة، ووسيطها مع 100 طلب 119 مللي ثانية، وهذا هو ثمن التوزيع نفسه دون أي ذيل.

والمشكلة التي واجهتنا هنا أن أول تصميم للتجربة كان مثل مثال الورقة بالضبط: 2 مللي ثانية عادة و100 مللي ثانية في 1% من الحالات. وهذه كانت النتيجة:

```text
== leaf0 N=1
    fanout_round...................: med=8ms    p(95)=36.04ms p(99)=61.04ms max=96ms
== leaf0 N=10
    fanout_round...................: med=22ms    p(95)=61ms    p(99)=86.02ms max=629ms
== leaf0 N=50
    fanout_round...................: med=70ms    p(95)=142.04ms p(99)=226.21ms max=675ms
== leaf0 N=100
    fanout_round...................: med=128ms    p(95)=261.19ms p(99)=386.35ms max=908ms
== leaf N=1
    fanout_round...................: med=4ms    p(95)=20.04ms p(99)=101.01ms max=213ms
== leaf N=10
    fanout_round...................: med=9ms    p(95)=102.04ms p(99)=111ms    max=129ms
== leaf N=50
    fanout_round...................: med=54ms    p(95)=133.04ms p(99)=147.07ms max=244ms
== leaf N=100
    fanout_round...................: med=120ms    p(95)=179.14ms p(99)=202.01ms max=251ms
```

الخدمة بلا ذيل `leaf0` كانت أبطأ في بعض الحالات من الخدمة التي فيها ذيل، والسبب أن كلفة إرسال مئة طلب عبر HTTP واستقبالها في Python كانت أكبر من الذيل الذي نقيسه، 128 مللي ثانية للتوزيع وحده مقابل 100 مللي ثانية للطلب البطيء، فاختلط الأثران. والحل كان أن نكبر المقياس: طلب عادي 20 مللي ثانية وبطيء 1.5 ثانية، فيبقى الذيل أكبر بوضوح من كلفة التوزيع، ونعد الجولات فوق ثانية واحدة. والدرس العام أن أي تجربة أداء تقيس أثراً صغيراً يجب أن تعرف أولاً كلفة أداة القياس نفسها، وهنا كانت `leaf0` هي هذا المرجع.

### الأرقام المقاسة مقابل جدول Dean

| العملية                             | جدول Dean      | قسناه (الوسيط)                                |
| ----------------------------------- | -------------- | --------------------------------------------- |
| مرجع L1                             | 0.5 نانوثانية  | 1.0 نانوثانية                                 |
| مرجع L2                             | 7 نانوثوان     | 3.4 إلى 4.7 نانوثانية                         |
| قفل Mutex وفكه                      | 25 نانوثانية   | 22 إلى 30 نانوثانية                           |
| مرجع الذاكرة الرئيسية               | 100 نانوثانية  | 115 إلى 330 نانوثانية                         |
| قراءة 1 ميجابايت متتالية من الذاكرة | 250 ميكروثانية | 50 إلى 85 ميكروثانية                          |
| قراءة 4 كيلوبايت عشوائية من SSD     | 150 ميكروثانية | 188 ميكروثانية في وقت هادئ                    |
| قراءة 1 ميجابايت متتالية من SSD     | 1 مللي ثانية   | 1.07 مللي ثانية                               |
| ذهاب وعودة داخل مركز البيانات       | 500 ميكروثانية | HTTP بين Containers 1 مللي ثانية، وRedis 0.17 |
| ذهاب وعودة بين القارات              | 150 مللي ثانية | 139 إلى 291 مللي ثانية حسب الوجهة             |

الذاكرة المتتالية صارت أسرع بثلاثة إلى خمسة أضعاف من رقم Dean، وL2 أسرع، والقرص وقاعدة البيانات في الرتبة نفسها، والشبكة البعيدة لم تتغير لأن الضوء لم يصبح أسرع. وهذا ما يقوله رسم Colin Scott أيضاً: ما يعتمد على الترانزستور تحسن، وما يعتمد على الفيزياء والمسافة بقي كما هو.

### حذف التجربة Cleanup

```bash
docker compose down -v
docker rmi sw3-lat-bench:1 sw3-lat-api:1
```

والـ Volume المسمى `fio-data` فيه ملف الاختبار بحجم 2 جيجابايت، والأمر `down -v` يحذفه، فلا تنسه إذا شغلت fio على سيرفر قرصه صغير.

## ماذا تفعل بهذه الأرقام؟ قواعد عملية

- **عد الجولات قبل أن تحسن الاستعلامات:** طلب يرسل 50 استعلاماً متسلسلاً بنصف مللي ثانية هو 25 مللي ثانية قبل أي عمل، والحل جمعها في استعلام واحد أو اثنين.
- **لا تعبر المحيط في مسار الطلب:** أي استدعاء لخدمة بعيدة أثناء الطلب يضيف مئات المللي ثواني، فاجعله في الخلفية أو احفظ نتيجته.
- **أبق الاتصالات مفتوحة:** مجمع اتصالات لقاعدة البيانات، وعميل HTTP يعاد استخدامه، ونتائج DNS محفوظة.
- **صمم على p99 وليس على الوسيط:** وخاصة إذا كان الطلب يستدعي عدة خدمات، فالذيل يتضاعف مع كل خدمة إضافية.
- **اترك هامشاً في كل مورد:** الاستخدام 60% إلى 70% في الذروة، لأن الزمن يرتفع فجأة بعد ذلك كما رأيت عند 340 طلباً في الثانية.
- **احسب السعة بقانون Little لكل مورد في الطريق:** العمال، والاتصالات، والمعالج، والقرص، والأصغر هو سعتك.
- **قس على أجهزتك، أكثر من مرة، وفي أوقات مختلفة:** فالذيل في الساعة المزدحمة قد يكون ثلاثين ضعف الذيل في الساعة الهادئة.

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

- **مراقبة المتوسط وحده:** المتوسط في التجربة كان مقبولاً في حالات كان فيها p99 أكبر منه بعشرين ضعفاً.
- **اختبار ضغط بنموذج مغلق ثم الحكم على السعة:** النموذج المغلق يبطئ الإرسال عندما يبطئ السيرفر، فيخفي الانهيار الذي رأيناه عند 340 طلباً في الثانية.
- **حفظ جدول Dean كما هو:** بعض أرقامه تغيرت بخمسة أضعاف، والنسب بين الدرجات هي ما يبقى صحيحاً.
- **قياس مرة واحدة:** رأيت كيف تغير رقم L3 أربعة أضعاف وp99 ثلاثين ضعفاً بين تشغيلين.
- **زيادة العمال لحل كل بطء:** ثمانية عمال لم يرفعوا السعة إلى الضعف، لأن المعالج صار هو الحد.
- **تقسيم خدمة إلى خدمات كثيرة دون حساب الذيل:** مئة خدمة كل منها ممتازة في 99% من الحالات تعطي صفحة بطيئة في 63% من الحالات.
- **إهمال كلفة القياس نفسه:** كما في التصميم الأول لتجربة الذيل، حيث كانت كلفة التوزيع أكبر من الأثر المقاس.

## قائمة تحقق Checklist

- أعرف رتبة كل عملية في مسار الطلب: نانوثانية أم ميكروثانية أم مللي ثانية.
- عددت الجولات عبر الشبكة في الطلب الواحد، المتسلسلة منها والمتوازية.
- لا يوجد استدعاء متسلسل لخدمة بعيدة أو بطيئة في مسار الطلب.
- أراقب p50 وp95 وp99 لكل خدمة، وليس المتوسط فقط.
- حسبت بقانون Little عدد العمال والاتصالات اللازمة في الذروة، مع هامش.
- أعرف المورد الذي يصل إلى حده أولاً، وقسته باختبار ضغط بنموذج مفتوح.
- أعرف عدد الخدمات التي ينتظرها الطلب الواحد، وما p99 لكل منها.
- كررت القياس في أوقات مختلفة، وأعرف كم يتذبذب الذيل.

## ماذا تقرأ بعد ذلك؟ Next Steps

هذا المقال يعطيك الأرقام التي تبني عليها بقية مرحلة تصميم الأنظمة: كيف تصمم الواجهة API، وكيف تتواصل الأنظمة بالأحداث عبر Webhooks، وأين تضع التخزين المؤقت، وكيف تحدد معدل الطلبات حتى لا تصل إلى نقطة الانهيار التي رأيناها:

[![](https://arabroot.io/content/images/2026/11/api-basics-cover-cover.webp)دليلما هي واجهة API؟ الطلب والاستجابة ورموز الحالة بمثالواجهة API من أول طلب إلى أول خطأ: الطلب والرد وJSON ورموز الحالة على واجهة فعاليات حقيقية بلغة Python، مع الأخطاء التي صنعناها بأيدينا وما يفعله الكلاينت مع كل منها.](https://arabroot.io/articles/%D9%85%D8%A7-%D9%87%D9%8A-%D9%88%D8%A7%D8%AC%D9%87%D8%A9-api-%D8%A7%D9%84%D8%B7%D9%84%D8%A8-%D9%88%D8%A7%D9%84%D8%A7%D8%B3%D8%AA%D8%AC%D8%A7%D8%A8%D8%A9-%D9%88%D8%B1%D9%85%D9%88%D8%B2-%D8%A7%D9%84%D8%AD%D8%A7%D9%84%D8%A9-status-codes/)[![](https://arabroot.io/content/images/2026/10/api-design-cover-cover.webp)دليلكيف تصمم API يبقى متوافقاً مع عملائه بعد سنةمبادئ تصميم API يتطور دون أن يعطل التطبيقات التي تعتمد عليه، وكيف تختار الشكل المناسب لنظامك.](https://arabroot.io/articles/%D8%AA%D8%B5%D9%85%D9%8A%D9%85-%D9%88%D8%A7%D8%AC%D9%87%D8%A7%D8%AA-api-rest-%D9%88-grpc-%D9%88-graphql/)[![](https://arabroot.io/content/images/2026/11/webhooks-cover-cover.webp)دليلWebhooks: كيف ترسل الأحداث بين الأنظمة وتستقبلها بأمانكيف تستقبل رسائل الـ Webhook وترسلها دون أن تخدعك رسالة مزورة أو مكررة أو قديمة، مع تجربة تعيد كل عطل من التوقيع الخاطئ إلى ثلاثة إيصالات لدفعة واحدة.](https://arabroot.io/articles/webhooks-%D9%83%D9%8A%D9%81-%D8%AA%D8%B1%D8%B3%D9%84-%D8%A7%D9%84%D8%A7%D8%AD%D8%AF%D8%A7%D8%AB-%D8%A8%D9%8A%D9%86-%D8%A7%D9%84%D8%A7%D9%86%D8%B8%D9%85%D8%A9-%D9%88%D8%AA%D8%B3%D8%AA%D9%82%D8%A8%D9%84%D9%87%D8%A7-%D8%A8%D8%A7%D9%85%D8%A7%D9%86/)[![](https://arabroot.io/content/images/2026/10/caching-strategies-cover-cover.webp)دليلالتخزين المؤقت Caching بالتفصيل: الاستراتيجيات والإبطالكيف تختار نمط التخزين المؤقت المناسب، ومتى تبطل القيمة، وكيف تمنع انهيار قاعدة البيانات عندما ينتهي مفتاح مشهور.](https://arabroot.io/articles/%D8%A7%D9%84%D8%AA%D8%AE%D8%B2%D9%8A%D9%86-%D8%A7%D9%84%D9%85%D8%A4%D9%82%D8%AA-caching-%D8%A7%D9%84%D8%A7%D8%B3%D8%AA%D8%B1%D8%A7%D8%AA%D9%8A%D8%AC%D9%8A%D8%A7%D8%AA-%D9%88%D8%A7%D9%84%D8%A7%D8%A8%D8%B7%D8%A7%D9%84/)[![](https://arabroot.io/content/images/2026/10/rate-limiting-cover-cover.webp)دليلتحديد معدل الطلبات Rate Limiting وخوارزمياتهكيف تعمل خوارزميات تحديد معدل الطلبات، وأيها يناسب واجهتك، وكيف تطبقها على عدة سيرفرات وترد بالرمز 429 الصحيح.](https://arabroot.io/articles/%D8%AA%D8%AD%D8%AF%D9%8A%D8%AF-%D9%85%D8%B9%D8%AF%D9%84-%D8%A7%D9%84%D8%B7%D9%84%D8%A8%D8%A7%D8%AA-rate-limiting-%D9%88%D8%AE%D9%88%D8%A7%D8%B1%D8%B2%D9%85%D9%8A%D8%A7%D8%AA%D9%87/)[![](https://arabroot.io/content/images/2026/11/background-jobs-cover-cover.webp)دليلالمهام الخلفية Background Jobs: لماذا لا ينتظر المستخدم؟كيف تخرج إرسال البريد ومعالجة الملفات من الطلب إلى عامل يعمل في الخلفية، مع تجربة على Celery وRedis تقيس زمن الطلب قبل وبعد وتقتل العامل في منتصف مهمة.](https://arabroot.io/articles/%D8%A7%D9%84%D9%85%D9%87%D8%A7%D9%85-%D8%A7%D9%84%D8%AE%D9%84%D9%81%D9%8A%D8%A9-background-jobs-%D9%84%D9%85%D8%A7%D8%B0%D8%A7-%D9%84%D8%A7-%D9%8A%D9%86%D8%AA%D8%B8%D8%B1-%D8%A7%D9%84%D9%85%D8%B3%D8%AA%D8%AE%D8%AF%D9%85/)

## الخلاصة Summary

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

- زمن الاستجابة هو زمن الطلب الواحد، والإنتاجية عدد الطلبات في الثانية، وهما مستقلان حتى يظهر الطابور، فيرتفع الزمن دون أن يتغير الكود.
- كل درجة في السلم أبطأ من التي قبلها بعشرة إلى ألف ضعف: نانوثانية في L1، ومئة نانوثانية في الذاكرة، ومئات الميكروثواني في القرص وقاعدة البيانات، ومئات المللي ثواني بين القارات.
- الذيل أهم من المتوسط، وفي التجربة تغير p99 ثلاثين ضعفاً بين وقت هادئ ووقت مزدحم بينما تغير الوسيط أقل من الضعف.
- الطلب الذي ينتظر مئة خدمة كل منها بطيئة في 1% من الحالات كان بطيئاً في 66% من الجولات، قريباً من 63% في ورقة The Tail at Scale.
- قانون Little طابق كل سطر في قياس القرص، وتنبأ بالانهيار الذي حدث في الخدمة بين 300 و340 طلباً في الثانية.
- مضاعفة العمال لم تضاعف السعة لأن المعالج صار هو الحد، فاحسب كل مورد في الطريق.

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

- 18 نوفمبر 2026: كتابة المقال، وتنفيذ التجربة على Docker Engine 29.8.0 مع debian:trixie-slim وgcc 14.2.0 وfio 3.39 وPython 3.13.5 وredis-py 6.1.0 وpsycopg 3.2.6 وRedis 8.10.3 وPostgreSQL 18.6 وgunicorn 27.0.1 على Python 3.13.18 وk6 1.8.3.