সরাসরি পর্বে যান
পর্ব ৪৬ · ৮২-এর মধ্যে · মডিউল ৮

Performance testing — load, stress, soak, spike আর percentile

Performance Testing Concepts: Load, Stress, Soak, Spike and Percentiles

Taught in Bangla, this lesson separates load, stress, soak, spike, scalability and volume tests, computes p50 to p99 from raw times to show why averages mislead, and builds workload models with think time, open and closed models and Little's law. A real 35-line load script sends 50 concurrent users to the Bazarghar search on localhost: p95 558 ms passes, while a seeded slow_search keeps the average under 2 seconds but pushes p95 to 2894 ms and fails NFR-2. Coordinated omission is explained.

এই পর্বে যা শিখবেন

  • Load, stress, soak, spike, scalability আর volume test আলাদা করে চেনা, আর কোন প্রশ্নে কোনটি লাগে তা বলা
  • Response time, throughput, error rate, concurrency, utilisation আর saturation মাপা ও পড়া
  • Raw সময় থেকে p50, p90, p95, p99 হিসাব করা, আর গড় কেন বিভ্রান্ত করে তা দেখানো
  • Think time, pacing, open বনাম closed model আর Little-এর সূত্র দিয়ে workload model বানানো
  • NFR-2-কে একটি চালানো যায় এমন test-এ রূপ দেওয়া, আর coordinated omission-সহ সাধারণ ভুল এড়ানো

১ · Performance testing কী — “দ্রুত” শব্দের পেছনের প্রশ্ন

ঈদের আগে কমলাপুর স্টেশনের টিকিট কাউন্টারের কথা ভাবুন। সাধারণ দিনে একজন যাত্রী এসে দুই মিনিটে টিকিট নিয়ে চলে যান। কাউন্টার ঠিকঠাক কাজ করে। কিন্তু ঈদের আগের সকালে লাইনে পাঁচশো মানুষ। কাউন্টার একই, কর্মী একই, নিয়ম একই; তবু কেউ দুই ঘণ্টা দাঁড়িয়ে থাকেন। কাউন্টার “কাজ করে” কি না, সেটি functional প্রশ্ন। ভিড়ে কত দ্রুত, কতজনকে, কতক্ষণ ধরে সেবা দিতে পারে, সেটি performance-এর প্রশ্ন।

Software-এও তাই। বাজারঘরের search একজন ক্রেতার জন্য ৩ মিলিসেকেন্ডে উত্তর দেয়; সব functional test সবুজ। কিন্তু সেলের রাতে হাজার ক্রেতা একসাথে খুঁজলে কী হবে? Performance testing হলো এমন testing, যা চাপ, সময় আর সম্পদের ব্যবহারের দিক থেকে system-এর আচরণ মাপে। এটি একটি non-functional testing: “কী করে” নয়, “কতটা ভালোভাবে করে” (পর্ব ০৫)।

ISO/IEC 25010 মানের মডেলে এই গুণের নাম performance efficiency, আর তার তিনটি ভাগ: সময়ের আচরণ (time behaviour), সম্পদের ব্যবহার (resource utilisation) আর ধারণক্ষমতা (capacity). মডেলটির পরিচয় সফটওয়্যার ইঞ্জিনিয়ারিং ও Git কোর্সের পর্ব ০৩-এ আছে। Tester-এর কাজ এই তিনটিকে মাপা যায় এমন প্রশ্নে বদলানো।

মূল ধারণা

প্রতিটি performance প্রশ্নে চারটি অংশ থাকে: কতজন (চাপ, যেমন ৫০ জন একসাথে), কী করছেন (কোন কাজ, কোন মিশ্রণে), কত দ্রুত চাই (যেমন p95 ≤ ২ সেকেন্ড, ভুল ≤ ১%) আর কোন অবস্থায় (কোন environment, কতক্ষণ, কত data). একটি অংশ বাদ গেলে ফলের অর্থ থাকে না।

পর্ব ১৫-এ (Requirement থেকে test) “রিভিউ জমা দ্রুত হবে” কথাটিকে বদলে লিখেছিলেন NFR-2: “৫০ জন একসাথে জমা দিলেও ৯৫% সাড়া ২ সেকেন্ডের মধ্যে (p95 ≤ ২ s)”. এই মডিউলের ছয়টি পর্বে NFR-2-কে আসল test-এ রূপ দেব। এই পর্বে ভিত্তি: ধরন, মাপকাঠি, percentile, workload আর একটি ছোট, হাতে লেখা load script. পরের পর্বগুলোতে Locust আর k6-এর মতো পূর্ণ tool, bottleneck খোঁজা, SLO আর frontend.

২ · Performance test-এর ধরন — চাপের আকার বদলালে প্রশ্ন বদলায়

সব performance test একই প্রশ্ন করে না। পার্থক্য মূলত চাপের আকারে: কতজন, কত দ্রুত বাড়ে, কতক্ষণ থাকে। ISTQB-এর Performance Testing syllabus (২০১৮ সালের দিকে প্রকাশিত)-এ কয়েকটি ধরন আলাদা করা হয়েছে; নিচের table তার ভাবার্থ, বাজারঘরের উদাহরণসহ। বইভেদে নামে একটু হেরফের থাকে।

ধরনচাপের আকারযে প্রশ্নের উত্তর দেয়বাজারঘরে উদাহরণ
Load testপ্রত্যাশিত চূড়া পর্যন্ত, ধরে রাখাপ্রত্যাশিত ভিড়ে লক্ষ্য টেকে কি?৫০ জন একসাথে search, NFR-2
Stress testচূড়া ছাড়িয়ে ধাপে ধাপেকোথায় ভাঙে, কীভাবে ভাঙে, ফেরে কি?২৫, ৫০, ৭৫, ১০০ জন, ভুল শুরু পর্যন্ত
Spike testহঠাৎ কয়েক গুণ, তারপর নামাধাক্কা সয়ে স্বাভাবিকে ফেরে কি?রাত ৯টায় ফ্ল্যাশ সেলের ঘোষণা
Soak test (endurance)মাঝারি চাপ, অনেক ঘণ্টাMemory leak, ভরে যাওয়া disk বা connection?সারা রাত স্বাভাবিক কেনাকাটা
Scalability testসম্পদ বাড়িয়ে একই চাপ বা বেশিWorker দ্বিগুণ করলে throughput কতটা বাড়ে?১ বনাম ২ app worker (পর্ব ৫০)
Volume testবিপুল data, চাপ সাধারণData বড় হলে কাজ ধীর হয় কি?১২টির জায়গায় ১০ লাখ পণ্যে search

এই ছয়টির বাইরে আরও দুটি নাম শুনবেন: capacity testing, যা লক্ষ্য না ভেঙে সর্বোচ্চ কতজন সামলানো যায় তা খোঁজে, আর concurrency testing, যা একই মুহূর্তে একই কাজ করলে ভুল হয় কি না দেখে (যেমন একই শেষ পণ্য দুজনে কেনা; সেই বিষয় পর্ব ৬২-এ, Concurrency আর async testing). এই ধরনগুলোর সাধারণ পরিচয় Cloud ও DevOps কোর্সের পর্ব ৬৮-এ আছে; এখানে আমরা tester-এর চোখে, পরিকল্পনা আর যাচাইয়ের দিক থেকে যাব।

চারটি প্রধান ধরনের চাপের আকার

Virtual users over time; the dashed line is the expected peak

Load, stress, spike আর soak test-এর ব্যবহারকারী বনাম সময়ের আকার Load · প্রত্যাশিত ভিড় Stress · সীমা খোঁজা Spike · হঠাৎ ভিড় Soak · দীর্ঘ সময় সময় → সময় → সময় → ঘণ্টার পর ঘণ্টা → চূড়া, ধরে রাখা ভাঙল কোথায়? কয়েক গুণ
ছবি ৪৬.১ — খাড়া অক্ষে একসাথে কতজন virtual user, আড়াআড়ি অক্ষে সময়; ড্যাশ দাগটি প্রত্যাশিত চূড়া। একই tool দিয়ে চারটিই চালানো যায়; বদলায় শুধু চাপের আকার আর প্রশ্ন।
  1. Load50 VUলক্ষ্য টেকে?
  2. Stress25→100কোথায় ভাঙে?
  3. Spike10→100ধাক্কা সয়?
  4. Soakঘণ্টার পর ঘণ্টাধীরে ক্ষয়?
  5. Scalability1 vs 2 workerসম্পদে লাভ?
  6. Volume10 লাখ পণ্যবড় data?
Loadপ্রত্যাশিত চূড়া
VU
50 ┤  ┌────────────┐
   │ ╱              ╲
 0 ┼╱────────────────╲ সময়
  ২ মিনিটে ওঠা, ১০ মিনিট ধরে রাখা
মাপ: p95, error rate
Stressধাপে ধাপে
VU               ✕ ?
100┤          ┌──┘
 75┤       ┌──┘
 50┤    ┌──┘  ← প্রত্যাশিত চূড়া
 25┤ ┌──┘
 0 ┼─┘────────────── সময়
প্রতি ধাপে p95 আর ভুল
Spikeহঠাৎ ধাক্কা
VU
100┤      ┌┐
   │      ││
 10┤──────┘└──────────
 0 ┼────────────────── সময়
  ১০ সেকেন্ডে ১০ গুণ, তারপর নামা
ফেরার সময়টিও মাপুন
Soakদীর্ঘ সময়
VU
50 ┤ ┌─────────···──────┐
 0 ┼─┘                  └ সময়
   memory, disk, connection
   শুরুতে বনাম শেষে
ঢাল দেখুন, শুধু গড় নয়
Scalabilityসম্পদ বনাম ফল
app worker   1      2
একই চাপ      ৫০ VU  ৫০ VU
মাপ          X, p95 X, p95
প্রশ্ন: দ্বিগুণ সম্পদে
throughput কত গুণ?
Volumeবড় data
পণ্য     12  →  10,00,000
VU       অল্প, স্থির
মাপ      search-এর p95
index আছে কি? (পর্ব ৪৯)
  1. Load test. প্রত্যাশিত চূড়ায়, এখানে NFR-2-এর ৫০ জন, ধীরে উঠে কিছুক্ষণ ধরে রাখা। প্রশ্ন একটাই: লক্ষ্য (p95 ≤ ২ s, ভুল প্রায় শূন্য) টেকে কি না। এটিই সবচেয়ে বেশি চলে, প্রায়ই প্রতিটি release-এর আগে।
  2. Stress test. চূড়া ছাড়িয়ে ধাপে ধাপে: ২৫, ৫০, ৭৫, ১০০ জন। প্রতিটি ধাপে p95 আর ভুল লেখা হয়। খোঁজা হয় কোন ধাপে latency হঠাৎ লাফায় (এই বাঁককে বলে knee), আর ভাঙার পর চাপ কমালে system নিজে ফেরে কি না।
  3. Spike test. স্বাভাবিক ১০ জন থেকে কয়েক সেকেন্ডে ১০০ জন, তারপর আবার নামা। Load test-এ ধীরে ওঠা system হঠাৎ ধাক্কায় অন্যভাবে আচরণ করতে পারে: queue উপচে পড়ে, timeout বাড়ে। ফেরার সময়টিও একটি মাপ।
  4. Soak test. স্বাভাবিক চাপে অনেক ঘণ্টা। ছোট test-এ যা দেখা যায় না তা ধরে: ধীরে বাড়া memory, ভরতে থাকা disk, ফেরত না দেওয়া connection. শুরুর আর শেষের মাপের পার্থক্যই এখানে আসল ফল।
  5. Scalability test. চাপ একই রেখে সম্পদ বদলানো: ১ বনাম ২ app worker. দ্বিগুণ সম্পদে throughput দ্বিগুণ না হলে কোথাও একটি ভাগ করা সম্পদ, যেমন database-এর lock, সীমা টানছে। বাজারঘরে সত্যিকারের তুলনা পর্ব ৫০-এ।
  6. Volume test. চাপ নয়, data বড়: ১২টি পণ্যের জায়গায় ১০ লাখ। ছোট database-এ সব query দ্রুত; বড় হলে index না থাকা query ধরা পড়ে। Index আর query plan দেখার কাজ পর্ব ৪৯-এ।

৩ · কী মাপব — response time থেকে saturation

Performance test-এর ফল কয়েকটি সংখ্যায় আসে। প্রতিটির অর্থ ঠিকভাবে না জানলে ভুল সিদ্ধান্ত হয়।

মাপকাঠিঅর্থএকক
Response timeClient অনুরোধ পাঠানো থেকে পুরো উত্তর পাওয়া পর্যন্ত সময়, অপেক্ষাসহms, s
Latencyপ্রায়ই response time-এর সমার্থক; কেউ কেউ শুধু অপেক্ষা বা নেটওয়ার্কের সময় বোঝান। রিপোর্টে সংজ্ঞা লিখে দিনms
Throughputপ্রতি সেকেন্ডে কতগুলো অনুরোধ শেষ হলো (পাঠানো নয়)req/s
Error rateমোট অনুরোধের কত ভাগ ব্যর্থ: 5xx, timeout, ভুল উত্তর%
Concurrencyএকই মুহূর্তে কতগুলো অনুরোধ বা ব্যবহারকারী system-এর ভেতরেসংখ্যা
Utilisationএকটি সম্পদ কত ভাগ সময় ব্যস্ত (CPU, disk, thread)%
Saturationসম্পদ পুরো ব্যস্ত, আর কাজ queue-তে জমছেqueue-র দৈর্ঘ্য

একটি সূক্ষ্ম কিন্তু জরুরি কথা: error rate ছাড়া response time-এর কোনো অর্থ নেই। একটি system ভিড়ে সব অনুরোধকে ৫ ms-এ “503 Service Unavailable” দিয়ে ফেরত দিতে পারে; response time চমৎকার, কিন্তু কেউ কিছু কিনতে পারেননি। তাই ভালো load test প্রতিটি উত্তরের status code আর দরকার হলে body-ও যাচাই করে, আর ব্যর্থ অনুরোধের সময় সফলগুলোর সাথে মেশায় না।

Response time আসলে কয়েকটি ভাগের যোগফল। কোন ভাগ বাড়ছে, সেটি না জানলে সমাধানও খোঁজা যায় না। নিচের stepper-এ বাজারঘরের একটি search অনুরোধের সময় ভাগ করে দেখানো হয়েছে, তিনটি অবস্থায়। সংখ্যাগুলো §৬-এর সত্যিকারের run-এর মাপা মোট সময় থেকে নেওয়া; ভাগগুলো সেই মোট থেকে বিয়োগ করে।

1client: GET /api/products?q=oil2uvicorn: event loop নেয়3thread pool: খালি thread?4search(): sleep + SQLite + JSON5client: উত্তর পেল, সময় লিখল
জমা সময় (ms)
ঠিক build, ১ জন
slow_search, ১০ জন
slow_search, ৫০ জন
  1. পাঠানো। Load script অনুরোধ পাঠায় আর ঘড়ি চালু করে। এই lab-এ app আর script একই যন্ত্রে, তাই নেটওয়ার্কের সময় প্রায় শূন্য। আসল ব্যবহারকারীর ক্ষেত্রে এখানে মোবাইল নেটওয়ার্কের দেরি যোগ হয়, যা server-এর মাপে দেখা যায় না।
  2. গ্রহণ। Uvicorn-এর event loop অনুরোধটি পড়ে। Search-এর endpoint একটি সাধারণ (sync) function, তাই FastAPI সেটিকে একটি thread pool-এ চালাতে পাঠায়।
  3. Thread-এর লাইন। anyio-র ডিফল্ট সীমায় এই pool-এ ৪০টি thread. ৫০ জন একসাথে থাকলে ৪০ জন thread পান, বাকি ১০ জন লাইনে দাঁড়ান। এই অপেক্ষা ≈ ১৩৭৯ ms: একটি saturation-এর চিহ্ন, যখন কোনো কাজ হয় না, শুধু সময় যায়।
  4. কাজ। ঠিক build-এ query আর JSON মিলিয়ে কয়েক ms. slow_search চালু থাকলে প্রতিটি search ১৫০০ ms ঘুমায়; এটিই বসানো ভুল। ১০ জনে কেউ লাইনে দাঁড়ান না, তাই মোট ≈ ১৫০৫ ms.
  5. মাপ। Client যা দেখে তা সব ভাগের যোগ। ৫০ জনের run-এ p90 ২৮৮৪ ms; তা থেকে একা থাকার সময় ১৫০৫ বাদ দিলে ১৩৭৯ ms শুধু লাইনের। ধীর কাজ আর লাইন, দুটি আলাদা সমস্যা; সমাধানও আলাদা।

৪ · Percentile — গড় কেন ঠকায়

ধরুন মিরপুর থেকে মতিঝিলে একই পথে দশ দিন রিকশায় গেলেন। নয় দিন লাগল ১০ মিনিট, আর একদিন জ্যামে আটকে ২ ঘণ্টা। গড় দাঁড়ায় (৯ × ১০ + ১২০) ÷ ১০ = ২১ মিনিট; অথচ কোনো দিনই ২১ মিনিট লাগেনি। Response time-এর গড়ও এমন: বেশিরভাগ দ্রুত অনুরোধ আর অল্প কয়েকটি খুব ধীর অনুরোধ মিলে এমন একটি সংখ্যা দেয়, যা কারও অভিজ্ঞতা নয়।

তাই performance-এর লক্ষ্য লেখা হয় percentile-এ। p95 = ১৫৫০ ms মানে সব সাড়া সাজালে ৯৫% সাড়া ১৫৫০ ms বা কম সময়ে এসেছে; বাকি ৫% এর চেয়ে ধীর। p50 হলো median, “সাধারণ” অভিজ্ঞতা; p95, p99 দেখায় বণ্টনের লম্বা লেজ, যাকে বলে tail latency. Percentile আর tail-এর system design-এর দিক System Design কোর্সের পর্ব ০৪-এ আছে; এখানে tester হিসেবে হাতে হিসাব করা আর লক্ষ্য যাচাই।

Percentile হিসাবের সবচেয়ে সরল নিয়ম nearest-rank: n টি মান ছোট থেকে বড় সাজান; p-তম percentile হলো ⌈p/100 × n⌉-তম মান। নিচের ২০টি সাড়ার সময়ে হাতে হিসাবটি দেখুন।

২০টি সাড়ার সময় (ms)
data
হিসাব
ফল
  1. গড়। ২০টি সময়ের যোগ ৯৫৯০, ভাগ ২০ = ৪৭৯.৫ ms. “গড়ে আধা সেকেন্ডের কম”, শুনতে চমৎকার। কিন্তু ২০টির ১৭টি ১৬০ ms বা কম, আর ৩টি দেড় সেকেন্ডের বেশি। ৪৭৯.৫ কারও অভিজ্ঞতা নয়।
  2. সাজানো। ছোট থেকে বড়। এখন বণ্টনটি চোখে পড়ে: একটি বড় দ্রুত দল (৯৫ থেকে ১৬০), তারপর বড় ফাঁক, তারপর তিনটি খুব ধীর মান।
  3. p50. ⌈০.৫০ × ২০⌉ = ১০, দশম মান ১২০ ms. অর্ধেক ক্রেতা ১২০ ms বা কম সময়ে উত্তর পান। (কোনো tool মাঝের দুই মানের গড় নেয়: ১২০ আর ১২২ থেকে ১২১; percentile-এর হিসাবের নিয়ম tool-ভেদে একটু আলাদা।)
  4. p90. ১৮-তম মান ১৫৫০ ms. প্রতি দশজনে একজন অন্তত দেড় সেকেন্ড অপেক্ষা করেন।
  5. p95. ১৯-তম মান ২৯০০ ms. NFR-2 (p95 ≤ ২০০০ ms) এই data-য় ব্যর্থ, যদিও গড় ৪৭৯.৫ ms. শুধু গড় দেখলে এই ব্যর্থতা ধরা পড়ত না।
  6. p99. ২০টি মানে p99 মানে সর্বোচ্চটিই, ৩১০০ ms. মাত্র ২০টি নমুনায় p99-এর তেমন অর্থ নেই; p99 বিশ্বাসযোগ্যভাবে বলতে শ'খানেক নয়, হাজারখানেক বা আরও বেশি নমুনা লাগে।

এবার একটি বড় নমুনা। নিচের ব্লকটি এই পাতাতেই চলে, ব্রাউজারে Pyodide দিয়ে। এটি ১০০০টি সাড়ার সময় বানায় একটি নির্দিষ্ট seed থেকে (তাই প্রতিবার একই ফল): ৯০০টি দ্রুত, cache থেকে আসা ধরনের, আর ১০০টি ধীর, যেমন cache-এ না পেয়ে database-এ যাওয়া। এমন দুই-চূড়ার বণ্টনকে বলে bimodal distribution. “চালান” চাপুন; প্রথমবার Pyodide নামতে কয়েক সেকেন্ড লাগে।

import random, statistics, math

rng = random.Random(46)                      # seeded: same numbers every run
fast = [rng.lognormvariate(math.log(180), 0.35) for _ in range(900)]
slow = [rng.lognormvariate(math.log(2600), 0.15) for _ in range(100)]
lat = fast + slow                            # 1000 response times in ms

def pct(xs, p):                              # nearest-rank percentile
    s = sorted(xs)
    return s[max(0, math.ceil(p / 100 * len(s)) - 1)]

mean = statistics.mean(lat)
print(f"n={len(lat)}  mean={mean:.0f} ms  median={statistics.median(lat):.0f} ms")
for p in (50, 90, 95, 99):
    print(f"  p{p:<3}= {pct(lat, p):5.0f} ms")
print("NFR-2 judged by mean:", "PASS" if mean <= 2000 else "FAIL")
print("NFR-2 judged by p95 :", "PASS" if pct(lat, 95) <= 2000 else "FAIL")

edges = [0, 250, 500, 1000, 2000, 2500, 3000, 4000]
print("histogram (one # = 40 requests, rounded up)")
for lo, hi in zip(edges, edges[1:]):
    k = sum(lo <= x < hi for x in lat)
    print(f"  {lo:>4}-{hi:<4} ms {k:>4} {'#' * math.ceil(k / 40)}")

আসল আউটপুট:

n=1000  mean=435 ms  median=187 ms
  p50 =   187 ms
  p90 =   652 ms
  p95 =  2639 ms
  p99 =  3108 ms
NFR-2 judged by mean: PASS
NFR-2 judged by p95 : FAIL
histogram (one # = 40 requests, rounded up)
     0-250  ms  767 ####################
   250-500  ms  131 ####
   500-1000 ms    2 #
  1000-2000 ms    4 #
  2000-2500 ms   29 #
  2500-3000 ms   49 ##
  3000-4000 ms   18 #

গড় ৪৩৫ ms; গড় দিয়ে বিচার করলে লক্ষ্য সহজেই PASS. কিন্তু p95 ২৬৩৯ ms, লক্ষ্য FAIL. গড়টি দ্রুত দলের প্রায় সবার চেয়ে ধীর, আর ধীর দলের চেয়ে অনেক দ্রুত; এটি কোনো দলেরই অভিজ্ঞতা নয়। Histogram-এ দুটি চূড়া স্পষ্ট: ২৫০ ms-এর নিচে ৭৬৭টি, আর ২০০০ থেকে ৪০০০ ms-এ ৯৬টি (২৯ + ৪৯ + ১৮)। লক্ষ করুন p90 (৬৫২ ms) এখনো দ্রুত দলের শেষ প্রান্তে, আর p95 লাফিয়ে ধীর দলে: ধীর দল মোটের ১০%, তাই p90-এর ঠিক পরেই লেজ শুরু। নিজে range(100)-কে range(40) করে চালান: ধীর দল ৪% হলে p95 আবার দ্রুত দিকে নামবে, কিন্তু p99 থাকবে ধীর দলে। কোন percentile বেছে নেবেন, তা ঠিক করে কতজনের খারাপ অভিজ্ঞতা আপনি মেনে নিচ্ছেন।

Percentile-এর গড় করবেন না। দুটি server-এর p95 যদি ৪০০ আর ২০০০ ms হয়, মিলিত p95 ১২০০ ms নয়; সেটি জানতে দুই server-এর সব raw সময় (বা histogram) একসাথে করে আবার হিসাব করতে হয়। একইভাবে প্রতি মিনিটের p95-এর গড় পুরো ঘণ্টার p95 নয়। Tool যদি শুধু সারাংশ রাখে, raw data বা histogram সংরক্ষণের ব্যবস্থা করুন।

৫ · Workload model — কে, কী, কত ঘন ঘন

Load test-এর সবচেয়ে কঠিন অংশ tool চালানো নয়; বাস্তবের মতো চাপ বানানো। এর পরিকল্পনাকে বলে workload model. এতে থাকে ব্যবহারকারীর যাত্রা (যেমন হোম → search → পণ্য → কার্ট → checkout), প্রতিটি যাত্রার ভাগ (১০০ জনের ৬০ জন শুধু দেখেন, ৩০ জন কার্টে তোলেন, ১০ জন কেনেন), আর দুই কাজের মাঝের বিরতি।

আসল মানুষ এক ক্লিকের পরেই আরেক ক্লিক করেন না: পণ্যের ছবি দেখেন, দাম মেলান, ফোন ধরেন। এই বিরতির নাম think time. Load tool-এর একেকজন নকল ব্যবহারকারী, অর্থাৎ virtual user (VU), think time ছাড়া চালালে একজন VU কয়েকশো আসল মানুষের সমান চাপ দিতে পারেন। আর pacing হলো একটি পুরো যাত্রা কত সময় পরপর শুরু হবে তা ঠিক করা, যাতে প্রতিটি VU-র গতি নিয়ন্ত্রিত থাকে।

Open বনাম closed model

চাপ দুইভাবে বর্ণনা করা যায়। Closed model-এ নির্দিষ্ট সংখ্যক ব্যবহারকারী থাকেন; প্রত্যেকে উত্তর পেলে (আর think time শেষে) পরের অনুরোধ পাঠান। ব্যাংকের ভেতরে পাঁচটি চেয়ার: পাঁচজনের বেশি কখনো অপেক্ষা করেন না। Open model-এ অনুরোধ আসে নির্দিষ্ট হারে, যাকে বলে arrival rate (যেমন প্রতি সেকেন্ডে ২০টি), server ধীর হোক বা না হোক; রাস্তার পাশের চায়ের দোকানে ক্রেতা আসতেই থাকেন, দোকানদার ধীর হলে ভিড় বাড়ে। ওয়েবসাইটে নতুন ক্রেতারা মূলত open model-এর মতো আসেন; একটি নির্দিষ্ট দলের কর্মী-ব্যবহারকারী (যেমন অফিসের ২০০ জন) closed-এর কাছাকাছি।

Little-এর সূত্র

John Little ১৯৬১ সালে একটি সাধারণ সম্পর্ক প্রমাণ করেন, যা এখন Little-এর সূত্র নামে পরিচিত: স্থির অবস্থায় একটি system-এর ভেতরে গড়ে যতজন (L) = আসার হার (λ) × প্রত্যেকের গড় থাকার সময় (W). Load test-এর ভাষায়, closed model-এ think time Z ধরলে: N = X × (R + Z), যেখানে N ব্যবহারকারী, X throughput, R response time. নিচের ব্লকে এই সূত্র দিয়ে দুটি প্রশ্নের উত্তর: সেলের দিনে ২০ search/সেকেন্ডের জন্য কতজন VU লাগবে, আর server ধীর হলে closed model-এর throughput কী হয়।

# Little's law for a closed system: N = X * (R + Z)
#   N users, X throughput (req/s), R response time (s), Z think time (s)
def users_needed(x, r, z):
    return x * (r + z)

def throughput(n, r, z):
    return n / (r + z)

target = 20        # searches per second on a sale day (invented target)
print(f"users needed for X = {target} req/s")
for r in (0.2, 2.0):
    for z in (0, 5, 15):
        print(f"  R={r:<3}s Z={z:<2}s -> N = {users_needed(target, r, z):5.0f}")

print("50 virtual users, no think time (closed model)")
for r in (0.2, 1.5, 3.0):
    print(f"  R={r:<3}s -> X = {throughput(50, r, 0):5.1f} req/s")

print("same 50 users, Z = 10 s")
for r in (0.2, 1.5, 3.0):
    print(f"  R={r:<3}s -> X = {throughput(50, r, 10):5.2f} req/s")

আসল আউটপুট:

users needed for X = 20 req/s
  R=0.2s Z=0 s -> N =     4
  R=0.2s Z=5 s -> N =   104
  R=0.2s Z=15s -> N =   304
  R=2.0s Z=0 s -> N =    40
  R=2.0s Z=5 s -> N =   140
  R=2.0s Z=15s -> N =   340
50 virtual users, no think time (closed model)
  R=0.2s -> X = 250.0 req/s
  R=1.5s -> X =  33.3 req/s
  R=3.0s -> X =  16.7 req/s
same 50 users, Z = 10 s
  R=0.2s -> X =  4.90 req/s
  R=1.5s -> X =  4.35 req/s
  R=3.0s -> X =  3.85 req/s

প্রথম অংশ: একই ২০ req/s চাপ দিতে think time ছাড়া মাত্র ৪ জন VU লাগে, কিন্তু ১৫ সেকেন্ড think time-এ ৩০৪ জন। তাই “৫০ জন ব্যবহারকারী” বললে think time না বললে কথাটি অসম্পূর্ণ: think time ছাড়া ৫০ VU বাস্তবের অনেক বেশি মানুষের চাপ দেয়। দ্বিতীয় অংশ: closed model-এ server ধীর হলে (R ০.২ থেকে ৩ সেকেন্ড) throughput ২৫০ থেকে ১৬.৭-এ নামে; load tool নিজেই কম অনুরোধ পাঠায়, কারণ প্রত্যেকে উত্তরের অপেক্ষায় বসে থাকে। আসল ক্রেতারা কিন্তু server ধীর বলে আসা থামান না। এই “নিজে থেকে চাপ কমানো” closed model-এর সবচেয়ে বড় ফাঁদ, যা §৮-এ coordinated omission নামে আবার আসবে। তৃতীয় অংশ: ১০ সেকেন্ড think time থাকলে R বদলালেও throughput প্রায় একই থাকে, কারণ মোট চক্রের বেশিরভাগই ভাবার সময়।

৬ · সত্যিকারের run — ৩৫ লাইনের একটি load script

পূর্ণ load tool (Locust, k6) পরের দুই পর্বে। এখানে উদ্দেশ্য ভেতরের যন্ত্রটি নিজের চোখে দেখা: অনুরোধ পাঠানো, সময় মাপা, percentile হিসাব। Python-এর asyncio (পাইথন প্রোগ্রামিং কোর্সের পর্ব ৪৫) দিয়ে একটি thread-এই অনেক অনুরোধ একসাথে চালানো যায়, আর httpx-এর async client (পর্ব ৩১) অনুরোধ পাঠায়।

Lab-এর পরিবেশ: একটি Windows ডেস্কটপে, আলাদা scratch ফোল্ডারে: Python 3.12, uv, httpx 0.28.1 (BSD-3-Clause). বাজারঘরের app (MIT; FastAPI, Uvicorn একটি worker-এ) নিজের কপি থেকে চলেছে 127.0.0.1:8821-এ, test mode-এ, নিজের database ফাইলে। একই ল্যাপটপে app আর load generator, তাই সংখ্যাগুলো আকার আর তুলনা দেখায়, production-এর ক্ষমতা নয়। কোনো বাইরের host-এ একটি অনুরোধও যায়নি; load test শুধু নিজের, অনুমতি পাওয়া system-এ চালাবেন।

import asyncio, sys, time, math, statistics
import httpx

BASE, PATH = "http://127.0.0.1:8821", sys.argv[1]
TOTAL, USERS, WARMUP = int(sys.argv[2]), int(sys.argv[3]), 20

def pct(xs, p):                                   # nearest-rank percentile
    s = sorted(xs)
    return s[max(0, math.ceil(p / 100 * len(s)) - 1)]

async def main():
    lat, errors, left = [], 0, TOTAL
    limits = httpx.Limits(max_connections=USERS)
    async with httpx.AsyncClient(base_url=BASE, timeout=30, limits=limits) as c:
        for _ in range(WARMUP):                   # warm-up, not measured
            await c.get(PATH)
        async def user():                         # closed model, no think time
            nonlocal errors, left
            while left > 0:
                left -= 1
                t0 = time.perf_counter()
                r = await c.get(PATH)
                lat.append((time.perf_counter() - t0) * 1000)
                errors += r.status_code != 200
        t0 = time.perf_counter()
        await asyncio.gather(*(user() for _ in range(USERS)))
        dur = time.perf_counter() - t0
    print(f"{PATH}  requests={len(lat)} users={USERS} errors={errors}")
    print(f"duration={dur:.1f}s  throughput={len(lat) / dur:.1f} req/s")
    print(f"mean={statistics.mean(lat):.0f}ms  " + "  ".join(
        f"p{p}={pct(lat, p):.0f}ms" for p in (50, 90, 95, 99)) + f"  max={max(lat):.0f}ms")
    p95 = pct(lat, 95)
    print(f"NFR-2 (p95 <= 2000 ms): {'PASS' if p95 <= 2000 else 'FAIL'}")

asyncio.run(main())

তিনটি নকশার সিদ্ধান্ত খেয়াল করুন। মাপা শুরুর আগে ২০টি অনুরোধের warm-up, যাতে প্রথম connection আর প্রথম query-র বাড়তি সময় মাপে না ঢোকে। প্রতিটি “user” একটি async লুপ, উত্তর পেলেই পরের অনুরোধ: closed model, think time ছাড়া, অর্থাৎ ইচ্ছা করে কঠোর চাপ। আর status code গোনা হয়, যাতে দ্রুত ভুল উত্তর ভালো ফল হিসেবে না আসে। প্রথমে ঠিক build, তিনটি চাপে (সত্যিকারের run):

cd ~/bazarghar-qa/app
BAZARGHAR_TEST_MODE=1 BAZARGHAR_DB=./perf.db uv run bazarghar --port 8821 --test-mode --reset
# another terminal
cd ~/bazarghar-qa/probe
uv run python loadprobe.py "/api/products?q=oil" 500 1
uv run python loadprobe.py "/api/products?q=oil" 500 10
uv run python loadprobe.py "/api/products?q=oil" 500 50
/api/products?q=oil  requests=500 users=1 errors=0
duration=1.7s  throughput=291.9 req/s
mean=3ms  p50=3ms  p90=4ms  p95=4ms  p99=6ms  max=6ms
NFR-2 (p95 <= 2000 ms): PASS
/api/products?q=oil  requests=500 users=10 errors=0
duration=1.4s  throughput=369.0 req/s
mean=27ms  p50=16ms  p90=50ms  p95=82ms  p99=144ms  max=186ms
NFR-2 (p95 <= 2000 ms): PASS
/api/products?q=oil  requests=500 users=50 errors=0
duration=2.1s  throughput=232.7 req/s
mean=204ms  p50=154ms  p90=433ms  p95=558ms  p99=866ms  max=1046ms
NFR-2 (p95 <= 2000 ms): PASS

ঠিক build-এ NFR-2 আরামে PASS (p95 ৫৫৮ ms). কিন্তু আকারটি দেখুন। ১ থেকে ১০ জনে throughput বাড়ল (২৯২ থেকে ৩৬৯ req/s), ১০ থেকে ৫০ জনে কমল (২৩৩), আর গড় সময় ২৭ থেকে ২০৪ ms. এটি saturation-এর চেনা ছবি: সম্পদ পুরো ব্যস্ত, তাই বাড়তি ব্যবহারকারী শুধু লাইন লম্বা করে। Little-এর সূত্রও মিলছে: ৫০ জন ≈ ২৩২.৭ × ০.২০৪ s ≈ ৪৭.৫; ১০ জন ≈ ৩৬৯ × ০.০২৭ ≈ ১০.০। একই ৫০ জনের run আরেকবার চালাতে p95 এল ৪৬৬ ms: মাপে পর্ব ৪০-এর মতো noise আছে, তাই একটি run দেখে সিদ্ধান্ত নয়।

এবার app থামিয়ে বসানো ভুল slow_search চালু করে আবার চালানো হলো (--bugs slow_search), ১০, ৪০ আর ৫০ জনে:

/api/products?q=oil  requests=200 users=10 errors=0
duration=30.2s  throughput=6.6 req/s
mean=1507ms  p50=1505ms  p90=1509ms  p95=1523ms  p99=1529ms  max=1539ms
NFR-2 (p95 <= 2000 ms): PASS
/api/products?q=oil  requests=400 users=40 errors=0
duration=15.2s  throughput=26.2 req/s
mean=1515ms  p50=1504ms  p90=1554ms  p95=1582ms  p99=1604ms  max=1628ms
NFR-2 (p95 <= 2000 ms): PASS
/api/products?q=oil  requests=500 users=50 errors=0
duration=19.7s  throughput=25.4 req/s
mean=1875ms  p50=1559ms  p90=2884ms  p95=2894ms  p99=3044ms  max=3049ms
NFR-2 (p95 <= 2000 ms): FAIL

এই পর্বের মূল ফল এই শেষ run-এ। গড় ১৮৭৫ ms, অর্থাৎ ২ সেকেন্ডের নিচে; কিন্তু p95 ২৮৯৪ ms, তাই NFR-2 FAIL. কেউ যদি requirement লিখতেন “গড় সাড়া ২ সেকেন্ডের কম”, এই ধীর build পাস করে যেত। p50 (১৫৫৯) আর p90 (২৮৮৪)-এর মাঝে বিশাল লাফ বলে দেয় বণ্টন দুই দলে ভাগ: ৪০টি thread-এ যাঁরা জায়গা পান তাঁরা ≈ ১.৫ s, বাকি ১০ জন লাইনে দাঁড়িয়ে ≈ ২.৯ s. প্রমাণ ৪০ জনের run-এ: সবাই thread পান, তাই p95 ১৫৮২ ms, PASS. ৪০ থেকে ৫০ জনে, মাত্র দশজন বাড়তেই, লক্ষ্য ভেঙে গেল; এই হঠাৎ বাঁকই knee. আর ১০ জনে p95 ১৫২৩ ms, PASS: NFR-2-এ “৫০ জন একসাথে” না লেখা থাকলে এই ভুল কোনো test-এ ধরা পড়ত না। Little-এর সূত্রে যাচাই: ২৫.৪ × ১.৮৭৫ ≈ ৪৭.৬, প্রায় ৫০। একই ৫০ জনের ধীর run আবার চালাতে গড় ১৮৭৪ আর p95 ২৮৯৯ ms এল, অর্থাৎ ফলটি স্থির।

এই script-এর সীমা, সৎভাবে: এটি closed model, তাই server ধীর হলে নিজেই অনুরোধ কমায় (১০ জনে মাত্র ৬.৬ req/s). “৫০ জন একসাথে” ধরনের লক্ষ্য যাচাইয়ে এটি ঠিক আছে, কারণ NFR-2 নিজেই ব্যবহারকারীর সংখ্যায় লেখা। “প্রতি সেকেন্ডে ২০টি search”-এর মতো লক্ষ্যে open model লাগে, যা k6-এর arrival-rate executor দিয়ে পর্ব ৪৮-এ (k6 দিয়ে load test) দেখবেন। আর load generator একই ল্যাপটপে থাকায় সে নিজেও CPU নেয়; আসল test-এ generator আলাদা যন্ত্রে রাখুন আর তার নিজের CPU-ও মাপুন।

৭ · NFR-2 থেকে চালানো যায় এমন test

Requirement-এর বাক্য আর একটি test-এর মাঝে অনেক খোলা প্রশ্ন থাকে। “৫০ জন একসাথে জমা দিলেও p95 ≤ ২ s” পড়ে দুজন tester দুই রকম test বানাতে পারেন: একজন ৫ মিনিট চালান, আরেকজন ৩০ সেকেন্ড; একজন warm-up করেন, আরেকজন করেন না; একজন ভুল উত্তর বাদ দেন, আরেকজন মিশিয়ে ফেলেন। তখন একই build একজনের হাতে PASS, আরেকজনের হাতে FAIL. সমাধান হলো requirement-কে একটি test-এর শর্তসহ বিবরণী-তে লেখা।

NFR-2 → test
ধাপ
লেখা
  1. মূল বাক্য। পর্ব ১৫-এ product owner-এর সাথে লেখা NFR-2. এতে সংখ্যা আছে (৫০ জন, ৯৫%, ২ সেকেন্ড), তাই এটি test করা যায়; কিন্তু test-এর সব শর্ত এখনো নেই।
  2. অনুপস্থিত শর্ত। Tester প্রশ্নের তালিকা বানান: কোন কাজ (জমা, না search)? কতক্ষণ চাপ? warm-up কি মাপের অংশ? ব্যর্থ অনুরোধ কি “ধীর” হিসেবে গোনা হবে? কোন environment, কত data? প্রতিটি উত্তর test-এর একটি শর্ত হয়।
  3. Workload. ঠিক হলো: ৫০ VU, closed model, think time শূন্য, অর্থাৎ বাস্তবের চেয়ে কঠোর রূপ; এতে পাস করলে আসল ৫০ জনেও নিরাপদ থাকার কথা। মাপার আগে ২০টি warm-up, আর অন্তত ৩০০টি নমুনা, যাতে p95 কয়েকটি মানের ওপর না দাঁড়ায়।
  4. পরিমাপের নিয়ম। Percentile কোন পদ্ধতিতে (nearest-rank), সময় কোথা থেকে মাপা (client), আর শুধু সফল উত্তর সময়ের হিসাবে। নিয়ম লেখা থাকলে দুজন tester একই data থেকে একই সংখ্যা পাবেন।
  5. Pass/fail. দুটি শর্ত, দুটোই লাগবে: p95 ≤ ২০০০ ms আর error rate ≤ ১%. দ্বিতীয় শর্ত না থাকলে দ্রুত “503” দেওয়া system-ও পাস করত।
  6. ফল। §৬-এর সত্যিকারের run: ঠিক build-এ p95 ৫৫৮ ms, PASS; slow_search-এ p95 ২৮৯৪ ms, FAIL, যদিও গড় ১৮৭৫ ms. একই শর্তে চালানো বলে দুটি ফল তুলনীয়।

শর্তগুলো লেখা হয়ে গেলে test-টি কোডেও লেখা যায়, যেকোনো সাধারণ test-এর মতো। নিচের ব্লকে NFR-2-এর gate একটি function, আর তিনটি unittest: একটি ঠিক build-এর নমুনা, একটি ধীর build-এর নমুনা (যার আকার §৬-এর ৫০ জনের run-এর মতো: ৮০% ≈ ১.৫ s, ২০% ≈ ২.৯ s), আর একটি যা দেখে ছোট run-কে gate প্রত্যাখ্যান করে কি না। দ্বিতীয় test ইচ্ছা করে লাল।

import math, random, sys, unittest

def pct(xs, p):                               # nearest-rank percentile
    s = sorted(xs)
    return s[max(0, math.ceil(p / 100 * len(s)) - 1)]

def check_nfr2(lat_ms, errors, users):        # NFR-2 as code
    if users != 50 or len(lat_ms) < 300:
        raise ValueError("run does not meet the NFR-2 test conditions")
    assert errors / len(lat_ms) <= 0.01, f"error rate {errors}/{len(lat_ms)}"
    p95 = pct(lat_ms, 95)
    assert p95 <= 2000, f"p95 {p95:.0f} ms > 2000 ms"

rng = random.Random(46)
clean = [rng.lognormvariate(math.log(150), 0.6) for _ in range(500)]
slow = [1500 + rng.uniform(0, 60) for _ in range(400)] + \
       [2880 + rng.uniform(0, 160) for _ in range(100)]   # 40 threads busy

class Nfr2Gate(unittest.TestCase):
    def test_clean_build(self):
        check_nfr2(clean, errors=0, users=50)
    def test_slow_search_build(self):
        print(f" mean={sum(slow) / len(slow):.0f} ms", end=" ")
        check_nfr2(slow, errors=0, users=50)
    def test_too_small_run_is_rejected(self):
        with self.assertRaises(ValueError):
            check_nfr2(clean[:50], errors=0, users=5)

suite = unittest.defaultTestLoader.loadTestsFromTestCase(Nfr2Gate)
unittest.TextTestRunner(verbosity=2, stream=sys.stdout).run(suite)

আসল আউটপুট:

test_clean_build (__main__.Nfr2Gate.test_clean_build) ... ok
test_slow_search_build (__main__.Nfr2Gate.test_slow_search_build) ...  mean=1815 ms FAIL
test_too_small_run_is_rejected (__main__.Nfr2Gate.test_too_small_run_is_rejected) ... ok

======================================================================
FAIL: test_slow_search_build (__main__.Nfr2Gate.test_slow_search_build)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "main.py", line 24, in test_slow_search_build
    check_nfr2(slow, errors=0, users=50)
    ~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "main.py", line 12, in check_nfr2
    assert p95 <= 2000, f"p95 {p95:.0f} ms > 2000 ms"
           ^^^^^^^^^^^
AssertionError: p95 3004 ms > 2000 ms

----------------------------------------------------------------------
Ran 3 tests in 0.001s

FAILED (failures=1)

ধীর build-এর নমুনায় গড় ১৮১৫ ms, তবু gate লাল, আর বার্তা সরাসরি বলে কেন: p95 3004 ms > 2000 ms. তৃতীয় test-টি একটি অবহেলিত দিক দেখায়: gate নিজেও যাচাই করে run-টি NFR-2-এর শর্ত মেনেছে কি না (৫০ জন, অন্তত ৩০০ নমুনা)। ৫ জনের ৫০টি নমুনার run-কে gate “পাস” বা “ফেল” কোনোটিই বলে না, প্রত্যাখ্যান করে; নইলে কেউ ছোট run চালিয়ে সবুজ রিপোর্ট দেখাতে পারতেন। CI-তে এমন gate কীভাবে বসে আর আগের build-এর সাথে তুলনা করে, তা পর্ব ৫০-এ।

৮ · Performance test-এর প্রক্রিয়া আর সাধারণ ভুল

Performance testing একবারের কাজ নয়, একটি চক্র: পরিকল্পনা (লক্ষ্য, workload, environment) → script (যাত্রা, data, যাচাই) → baseline (বর্তমান build-এর মাপ, যার সাথে পরে তুলনা) → run → বিশ্লেষণ (percentile, ভুল, সম্পদ) → tuning বা সমাধান → আবার run, একই শর্তে। শেষ ধাপটিই সবচেয়ে বেশি বাদ পড়ে: সমাধানের পর একই workload-এ না মাপলে সমাধান কাজ করল কি না, কেউ জানেন না।

Test environment কতটা বাস্তব

Production-এর চেয়ে ছোট test environment-এ পাওয়া সংখ্যা সরাসরি production-এ খাটে না। পার্থক্য আসে যন্ত্রের সংখ্যা ও আকারে, data-র পরিমাণে (১২টি পণ্য বনাম লাখ পণ্য), cache-এর অবস্থায়, নেটওয়ার্কে, আর বাইরের service-এ (এখানে নকল payment gateway). তাই রিপোর্টে environment-এর বিবরণ লিখুন, আর ফলকে বলুন “এই environment-এ”। ছোট environment-এর ফল তবু কাজের: একই environment-এ দুই build-এর তুলনা, যেমন §৬-এ ঠিক বনাম slow_search, বিশ্বাসযোগ্য।

সাধারণ ভুলের তালিকা

ভুলফলপ্রতিকার
Warm-up নেইপ্রথম connection, ঠান্ডা cache-এর সময় মাপে ঢোকেWarm-up আলাদা, মাপের বাইরে
Load generator আর app একই যন্ত্রেদুজনে CPU ভাগ করে; generator নিজেই bottleneck হতে পারেআলাদা যন্ত্র; generator-এর CPU-ও মাপা
খুব ছোট runp95, p99 কয়েকটি মানের ওপর দাঁড়ায়যথেষ্ট নমুনা; একাধিক run
শুধু গড়লেজের সমস্যা লুকায়p50, p95, p99, max আর histogram
একই অনুরোধ বারবারCache-এর গুণে অবাস্তব দ্রুতবৈচিত্র্যময় test data, ভিন্ন search শব্দ
ভুল উত্তর গোনা হয় নাদ্রুত 503-ও “ভালো” সময়Status আর body যাচাই; error rate আলাদা
Think time ভুলVU-র সংখ্যার অর্থ বদলে যায়Little-এর সূত্রে হিসাব, workload লেখা
Coordinated omissionধীর মুহূর্তের মাপ হারিয়ে যায়Open model বা পরিকল্পিত সময় থেকে মাপা

Coordinated omission — ধীর মুহূর্ত যেভাবে হারায়

শেষ ভুলটি সবচেয়ে সূক্ষ্ম। নামটি জনপ্রিয় করেন Gil Tene, ২০১০-এর দশকের শুরুর দিকে latency মাপা নিয়ে তাঁর বক্তৃতায় (বলে উল্লেখ করা হয়)। ধারণাটি: একটি closed-model tool প্রতি ১০ ms-এ একটি অনুরোধ পাঠাতে চায়। হঠাৎ server ২ সেকেন্ড থেমে যায়। Tool তখন উত্তরের অপেক্ষায় বসে থাকে, তাই ওই ২ সেকেন্ডে যে প্রায় ২০০টি অনুরোধ পাঠানোর কথা ছিল, সেগুলো পাঠানোই হয় না, মাপাও হয় না। Tool আর server যেন “সমন্বয় করে” ধীর মুহূর্তটি মাপ থেকে বাদ দিল। আসল ক্রেতারা কিন্তু ওই ২ সেকেন্ডেও আসছিলেন। নিচের simulation-এ দুইভাবে মাপা হয়েছে: tool নিজের পাঠানোর সময় থেকে, আর পরিকল্পিত সময় থেকে (open model বা সংশোধিত মাপ)।

import math

def pct(xs, p):                               # nearest-rank percentile
    s = sorted(xs)
    return s[max(0, math.ceil(p / 100 * len(s)) - 1)]

def done(start):            # server: 5 ms per request, frozen 5000..7000 ms
    return (7000 if 5000 <= start < 7000 else start) + 5

plan = [i * 10 for i in range(1000)]          # one request every 10 ms, 10 s

# A) closed tool: waits for the reply, measures from ITS OWN send time
closed, t = [], 0
for s in plan:
    send = max(s, t)                          # cannot send before reply
    t = done(send)
    closed.append(t - send)

# B) open model: latency counted from the PLANNED start time
opened, free = [], 0
for s in plan:
    start = max(s, free)                      # waits in the queue
    free = done(start)
    opened.append(free - s)

for name, xs in (("closed tool", closed), ("open/corrected", opened)):
    slow = sum(x > 1000 for x in xs)
    print(f"{name:<15} p50={pct(xs, 50):4.0f}  p99={pct(xs, 99):4.0f}"
          f"  max={max(xs):4.0f} ms  over 1 s: {slow}")

আসল আউটপুট:

closed tool     p50=   5  p99=   5  max=2005 ms  over 1 s: 1
open/corrected  p50=   5  p99=1955  max=2005 ms  over 1 s: 201

একই server, একই ২ সেকেন্ডের থেমে থাকা। Closed tool-এর হিসাবে ১০০০টির মধ্যে মাত্র ১টি অনুরোধ ১ সেকেন্ডের বেশি, তাই p99 = ৫ ms: রিপোর্ট বলবে system চমৎকার। পরিকল্পিত সময় থেকে মাপলে ২০১টি অনুরোধ ১ সেকেন্ডের বেশি অপেক্ষা করেছে, p99 = ১৯৫৫ ms. দুটি সংখ্যার পার্থক্য প্রায় চারশো গুণ, অথচ server-এর আচরণ এক। প্রতিকার: arrival rate ঠিক রেখে চাপ দেওয়া (open model), অথবা tool-এর মাপকে পরিকল্পিত সময় থেকে সংশোধন করা। কিছু tool এই সংশোধন নিজে করে; আপনার tool করে কি না, তার নথিতে দেখুন।

আরও গভীরে: Open আর closed model-এর পার্থক্য নিয়ে Bianca Schroeder, Adam Wierman আর Mor Harchol-Balter-এর ২০০৬ সালের গবেষণাপত্র “Open Versus Closed: A Cautionary Tale” দেখায়, একই system দুই model-এ খুব আলাদা response time দিতে পারে, আর ভুল model বেছে নিলে নকশার সিদ্ধান্তও ভুল হয়। Latency-র লেজ বড় system-এ কেন আরও জরুরি, তা নিয়ে Jeffrey Dean আর Luiz André Barroso-র ২০১৩ সালের লেখা “The Tail at Scale” বহুল উদ্ধৃত। আর percentile ঠিকভাবে জমাতে HdrHistogram-এর মতো histogram কাঠামো ব্যবহার হয়, যা সব raw সময় না রেখেও নির্দিষ্ট নির্ভুলতায় percentile দেয়।

পরীক্ষা ও ইন্টারভিউতে:

  • Load আর stress test-এর পার্থক্য? Load test প্রত্যাশিত চাপে লক্ষ্য টেকে কি না দেখে; stress test চাপ সীমা ছাড়িয়ে ভাঙার বিন্দু আর ফেরার আচরণ খোঁজে।
  • Soak test কী ধরে? দীর্ঘ সময়ে ধীরে জমা সমস্যা: memory leak, connection ফেরত না দেওয়া, disk ভরে যাওয়া।
  • Requirement-এ গড়ের বদলে p95 কেন? গড় অল্প কিছু খুব ধীর অনুরোধ লুকিয়ে ফেলে; p95 বলে ৯৫% ব্যবহারকারীর অভিজ্ঞতা কত খারাপ পর্যন্ত যায়।
  • Little-এর সূত্র? L = λW; closed load test-এ N = X × (R + Z). উদাহরণ: X = ২০ req/s, R = ০.২ s, Z = ৫ s হলে N = ১০৪.
  • Think time কেন? আসল মানুষ ক্লিকের মাঝে থামেন; think time ছাড়া অল্প VU অনেক বেশি মানুষের চাপ দেয়, ফলে ফলের অর্থ বদলায়।

৯ · AI-এর যুগে — AI দিয়ে load test লেখানো আর ফল পড়ানো

AI সহকারীকে “বাজারঘরের জন্য একটি load test লিখে দাও” বললে কয়েক সেকেন্ডে একটি script আসে। চেনা ঝুঁকিগুলো: শুধু সুখী পথের একটি endpoint, একই অনুরোধ বারবার (cache-এর গুণে অবাস্তব দ্রুত); think time হিসেবে প্রতিটি ধাপে অন্ধ sleep(1); status code যাচাই নেই; ফলে শুধু গড়; tool-এর এমন option, যা আসলে নেই; target URL হিসেবে একটি আসল website, যা চালানো আইনত ও নৈতিকভাবে অন্যায়; আর না চালিয়েই “system ৫০০ জন সামলাতে পারবে” ধাঁচের দাবি। Load-এর ফল পড়াতে দিলেও AI গড় দেখে সন্তুষ্ট হতে পারে, বা একটি run থেকে সাধারণ সিদ্ধান্ত টানতে পারে।

AI-কে স্পষ্ট শর্ত দিন, আর যাচাইয়ের দায়িত্ব নিজের কাছে রাখুন:

তুমি একজন অভিজ্ঞ performance tester. বাজারঘরের (আমার নিজের, localhost-এ চলা app) জন্য Python asyncio আর httpx দিয়ে একটি ছোট load script লিখবে। শর্ত: ১. শুধু http://127.0.0.1:8821-এ অনুরোধ যাবে; অন্য কোনো host নয়। ২. Requirement: NFR-2 = ৫০ জন একসাথে থাকলে p95 ≤ 2000 ms আর error rate ≤ 1%. গড় দিয়ে pass/fail ঠিক করবে না। ৩. মাপার আগে warm-up, যা ফলে ঢুকবে না। প্রতিটি উত্তরের status code যাচাই করবে, ব্যর্থ অনুরোধ আলাদা গুনবে। ৪. Search শব্দ একটি তালিকা থেকে ঘুরিয়ে নেবে, একই শব্দ বারবার নয়। ৫. Percentile কোন পদ্ধতিতে হিসাব করছ, কোডে মন্তব্যে লিখবে। script closed না open model, আর তার সীমা কী, তাও বলবে। ৬. httpx-এর যে option ব্যবহার করবে, তা official নথির কোথায় আছে বলবে। ৭. তুমি script চালাওনি; কোনো ফল বা "পাস করবে" দাবি করবে না।

AI-এর লেখা load test বা বিশ্লেষণ হাতে পেলে — চেকলিস্ট

ভাবনার প্রশ্ন

প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন — তারপর “→ উত্তর” চাপুন।

প্র ০১একটি একক অনুরোধের p99 ভালো হলেও একটি পুরো পাতার অভিজ্ঞতা খারাপ হতে পারে। কেন, আর এটি performance requirement লেখায় কী বদলায়?

একটি পাতা খুলতে প্রায়ই অনেকগুলো অনুরোধ লাগে: পণ্যের তথ্য, রিভিউ, দাম, কার্টের badge, সুপারিশ। পাতাটি তখনই তৈরি, যখন সবচেয়ে ধীর জরুরি অনুরোধটি শেষ হয়। ধরুন প্রতিটি অনুরোধ ১% সময় ধীর হয়, আর একটি পাতায় এমন ৩০টি অনুরোধ। তাহলে অন্তত একটি ধীর হওয়ার সম্ভাবনা ১ − ০.৯৯৩০, প্রায় ২৬%. অর্থাৎ অনুরোধের p99-এর সমস্যা পাতার স্তরে প্রায় প্রতি চারটিতে একটি পাতার সমস্যা।

Jeffrey Dean আর Luiz André Barroso ২০১৩ সালে Communications of the ACM-এ “The Tail at Scale” লেখায় এই ঘটনাকে বড় system-এর কেন্দ্রীয় সমস্যা হিসেবে তুলে ধরেন। যত বেশি অংশে একটি অনুরোধ ভাগ হয় (fan-out), তত বেশি একটি অংশের লেজ পুরো উত্তরের সময় ঠিক করে। তাঁরা দেখান, লেজ পুরো দূর করা প্রায় অসম্ভব, তাই নকশায় লেজ সহ্য করার কৌশল লাগে: একই অনুরোধ দেরিতে আরেক জায়গায় পাঠানো, সময়সীমা, কম fan-out.

Tester-এর জন্য এর তিনটি প্রভাব। এক, requirement কোন স্তরে লেখা, তা স্পষ্ট করতে হবে: একটি API অনুরোধের p95, না পুরো যাত্রার (search থেকে ফল দেখা পর্যন্ত)? দুটি আলাদা test. দুই, ব্যবহারকারী একটি সেশনে অনেক অনুরোধ করেন, তাই “p99 তো মাত্র ১%” কথাটি ভুল ধারণা দেয়: প্রায় প্রতিটি সক্রিয় ব্যবহারকারী সেশনে কখনো না কখনো লেজটি দেখেন। তিন, পাতার স্তরের মাপ লাগে, যা browser-এর দিক থেকে পর্ব ৫১-এ (Frontend performance) আসবে।

এই কারণেই বড় system-গুলোর লক্ষ্যে প্রায়ই p99 বা p99.9 দেখা যায়, শুধু p95 নয়। কিন্তু উচ্চ percentile-এর জন্য অনেক নমুনা লাগে; ২০টি নমুনায় p99 মানে শুধু সর্বোচ্চ মানটি। তাই লক্ষ্য যত উঁচু percentile-এ, test তত লম্বা বা তত বেশি অনুরোধের হতে হয়।

মূল উপলব্ধি: অনুরোধের লেজ যাত্রার স্তরে বহুগুণ হয়ে ধরা দেয়; তাই requirement-এ লিখুন কোন স্তরের কোন percentile, আর সেই percentile বিশ্বাসযোগ্য করতে যথেষ্ট নমুনা নিন।

প্র ০২“আমাদের load test ৫০০ জন ব্যবহারকারী চালিয়েছে” — এই কথা থেকে আসলে কতটুকু জানা যায়? Little-এর সূত্র আর open/closed model দিয়ে বিচার করুন।

প্রায় কিছুই না, যতক্ষণ না তিনটি তথ্য যোগ হয়: think time কত, model closed না open, আর throughput কত এল। John Little ১৯৬১ সালে প্রমাণ করেন L = λW, যা প্রায় যেকোনো স্থির queue-এ খাটে, ভেতরের নিয়ম যা-ই হোক। Load test-এ এর রূপ N = X × (R + Z). এই পর্বের হিসাবে ২০ req/s চাপ দিতে think time ছাড়া ৪ জন VU যথেষ্ট, আর ১৫ সেকেন্ড think time-এ ৩০৪ জন। অর্থাৎ “৫০০ জন” দিয়ে খুব হালকা থেকে খুব ভারী, যেকোনো চাপ বোঝানো যায়।

দ্বিতীয় প্রশ্ন model-এর। Closed model-এ প্রত্যেক VU উত্তরের অপেক্ষা করে। Server ধীর হলে throughput নিজে থেকে কমে; এই পর্বের সত্যিকারের run-এ ৫০ জনে ঠিক build-এ ২৩৩ req/s, ধীর build-এ মাত্র ২৫. আসল ওয়েবসাইটে নতুন ক্রেতারা server ধীর বলে আসা থামান না; তাঁরা আসতেই থাকেন, আর queue বাড়তে থাকে। তাই closed model ধীর অবস্থায় চাপ কম দেখায়, আর system-কে আসলের চেয়ে ভালো দেখায়।

Bianca Schroeder, Adam Wierman আর Mor Harchol-Balter ২০০৬ সালে NSDI সম্মেলনে “Open Versus Closed: A Cautionary Tale” প্রবন্ধে দেখান, একই system আর একই গড় চাপে open আর closed model-এ response time অনেক আলাদা হতে পারে, আর scheduling-এর মতো নকশার সিদ্ধান্তের প্রভাবও দুই model-এ আলাদা। তাঁদের সতর্কবার্তা ছিল: অনেক benchmark tool নিজের অজান্তেই closed model ব্যবহার করে, অথচ যে system-এর জন্য ফল প্রয়োগ হবে তা open-এর কাছাকাছি।

তাই একটি ভালো load test রিপোর্টে লেখা থাকে: workload model (closed বা open), VU বা arrival rate, think time আর pacing, পাওয়া throughput, আর Little-এর সূত্রে মিলিয়ে দেখা যে সংখ্যাগুলো সামঞ্জস্যপূর্ণ। এই পর্বের run-এ ২৫.৪ × ১.৮৭৫ ≈ ৪৭.৬, প্রায় ৫০; না মিললে মাপের কোথাও ভুল আছে, যেমন generator নিজেই আটকে আছে।

মূল উপলব্ধি: “কতজন ব্যবহারকারী” একা কোনো চাপ বোঝায় না; think time, model আর throughput-সহ বললে তবেই সংখ্যাটির অর্থ হয়, আর Little-এর সূত্র সেই সংখ্যাগুলোর সামঞ্জস্য যাচাইয়ের সহজ হাতিয়ার।

প্র ০৩Coordinated omission কেন বহু বছর ধরে অনেক load tool-এর রিপোর্টে নজর এড়িয়ে গেছে, আর একজন tester কীভাবে বুঝবেন তাঁর tool এই সমস্যায় ভুগছে কি না?

সমস্যাটি নজর এড়ায় কারণ ফলটি দেখতে স্বাভাবিক, এমনকি ভালো। Closed-model tool উত্তরের অপেক্ষায় বসে থাকে; server থেমে গেলে tool-ও থামে, তাই যে অনুরোধগুলো পাঠানোর কথা ছিল সেগুলো পাঠানো হয় না, মাপা হয় না। Server-এর সবচেয়ে খারাপ মুহূর্তের মাত্র একটি নমুনা রিপোর্টে আসে। এই পর্বের simulation-এ ২ সেকেন্ডের থেমে থাকায় closed tool-এর p99 ৫ ms, অথচ পরিকল্পিত সময় থেকে মাপলে ১৯৫৫ ms.

নামটি জনপ্রিয় করেন Gil Tene, ২০১০-এর দশকের শুরুর দিকে “How NOT to Measure Latency” ধাঁচের বক্তৃতায় (বলে উল্লেখ করা হয়)। তিনি HdrHistogram লাইব্রেরি আর জনপ্রিয় HTTP benchmark tool wrk-এর একটি সংশোধিত রূপ wrk2-এর সাথেও যুক্ত, যা নির্দিষ্ট হারে অনুরোধ পাঠায় আর পরিকল্পিত সময় থেকে latency মাপে। তাঁর মূল বক্তব্য ছিল, বহু প্রচলিত tool আর monitoring ব্যবস্থা উচ্চ percentile-কে অনেক কম করে দেখায়, আর লোকে সেই সংখ্যা দিয়ে SLA লেখে।

একজন tester কয়েকটি সহজ যাচাই করতে পারেন। এক, tool-এর নথিতে দেখুন সে closed (VU-ভিত্তিক) না open (arrival-rate-ভিত্তিক) model চালায়, আর সংশোধনের কোনো ব্যবস্থা আছে কি না। দুই, পরিকল্পিত আর পাওয়া throughput মেলান: ধীর অবস্থায় পাওয়া অনুরোধের হার পরিকল্পনার চেয়ে অনেক কমে গেলে omission হচ্ছে। তিন, নিজে একটি থেমে যাওয়া বানান: নিজের app-এ একটি endpoint কয়েক সেকেন্ড আটকে রাখুন, আর দেখুন রিপোর্টের p99 সেটি ধরে কি না। এই পর্বের simulation এই পরীক্ষারই ক্ষুদ্র রূপ।

সব ক্ষেত্রে open model-ই ঠিক, এমন নয়। NFR-2-এর মতো “৫০ জন একসাথে” ধাঁচের লক্ষ্যে closed model স্বাভাবিক, কারণ লক্ষ্যটি নিজেই একটি নির্দিষ্ট দলের কথা বলে। সমস্যা হয় যখন closed tool-এর ফল দিয়ে open-ধাঁচের প্রশ্নের উত্তর দেওয়া হয়, যেমন “প্রতি সেকেন্ডে ২০ জন নতুন ক্রেতা এলে কী হবে”।

মূল উপলব্ধি: যে tool server-এর সাথে থেমে যায়, সে ধীর মুহূর্ত মাপতে পারে না; প্রশ্নের ধরনের সাথে model মেলান, আর একটি ইচ্ছাকৃত থেমে যাওয়া দিয়ে tool-কেই test করুন।

প্র ০৪চালুর আগে load test-এ সব ঠিক থাকা সত্ত্বেও অনেক system প্রথম দিনেই ভিড়ে ভেঙে পড়ে। test environment আর workload-এর কোন পার্থক্য এর জন্য দায়ী হতে পারে?

একটি বহুল আলোচিত উদাহরণ যুক্তরাষ্ট্রের HealthCare.gov, যা ২০১৩ সালের অক্টোবরে চালু হয়ে প্রথম সপ্তাহগুলোতে ব্যাপক ধীরগতি আর ব্যর্থতার মুখে পড়ে। পরের সরকারি পর্যালোচনা আর সংবাদ প্রতিবেদনে চালুর আগে পূর্ণ system-এর end-to-end আর বাস্তব মাত্রার load testing-এর ঘাটতি, আর শেষ মুহূর্তের পরিবর্তনের কথা উঠে আসে বলে উল্লেখ করা হয়। বিস্তারিত বিতর্কিত হতে পারে, কিন্তু ধাঁচটি চেনা।

সাধারণ পার্থক্যগুলো এমন। Workload: test-এ সবাই একটি সরল পথ ধরেন, আসলে মানুষ লগইন, পাসওয়ার্ড ভোলা, একই পাতা বারবার refresh করেন; প্রথম দিনে সবাই একই সাথে নিবন্ধন করেন, যা সাধারণ দিনের মিশ্রণ নয়। Data: test database ছোট আর পরিষ্কার; আসল data বড়, পুরোনো, অসম, তাই query-র আচরণ আলাদা। Cache: test-এ একই অনুরোধ বারবার, তাই cache সব সামলায়; আসলে বৈচিত্র্য বেশি। নির্ভরতা: test-এ বাইরের service নকল (বাজারঘরের payment gateway-র মতো), যা কখনো ধীর হয় না; আসলে বাইরের service-ই প্রায়ই প্রথম bottleneck. Environment: test-এ কম যন্ত্র, ভিন্ন নেটওয়ার্ক, ভিন্ন config.

এই পর্বের lab নিজেই একটি ছোট উদাহরণ: app আর load generator একই ল্যাপটপে, ১২টি পণ্য, নেটওয়ার্ক প্রায় শূন্য। এখানে পাওয়া ২৩৩ req/s কোনোভাবেই production-এর ক্ষমতা নয়। কিন্তু একই environment-এ ঠিক আর ধীর build-এর তুলনা, আর ৪০ থেকে ৫০ জনে লক্ষ্য ভাঙার আকার, এই lab-এও বিশ্বাসযোগ্য।

প্রতিকার তাই কয়েকটি অভ্যাস: workload আসল ব্যবহারের তথ্য থেকে (log, analytics), নিবন্ধনের দিনের মতো বিশেষ দিনের আলাদা model; test data বড় আর বৈচিত্র্যময় (পর্ব ৬৫); নির্ভরতার ধীর হওয়াও test করা (পর্ব ৬৩-এর chaos testing); environment-এর পার্থক্য রিপোর্টে লেখা; আর চালুর পরে production-এ সতর্ক পর্যবেক্ষণ (পর্ব ৬৬)।

মূল উপলব্ধি: Load test শুধু ততটা সত্য, যতটা তার workload, data আর environment সত্য; পার্থক্যগুলো লিখে রাখুন, আর ছোট environment-এর ফলকে ক্ষমতা নয়, তুলনা হিসেবে পড়ুন।

প্র ০৫কিছু ভুল শুধু system অনেক ঘণ্টা চললে দেখা যায়। কেন ছোট load test এগুলো ধরে না, আর soak test কীভাবে পরিকল্পনা করবেন?

একটি ঐতিহাসিক উদাহরণ ১৯৯১ সালের উপসাগরীয় যুদ্ধের। সৌদি আরবের Dhahran-এ একটি Patriot ক্ষেপণাস্ত্র-প্রতিরক্ষা ব্যবস্থা একটি Scud ক্ষেপণাস্ত্র ঠেকাতে ব্যর্থ হয়, আর তাতে ২৮ জন মার্কিন সৈন্য নিহত হন। ১৯৯২ সালের মার্কিন GAO প্রতিবেদন অনুযায়ী কারণ ছিল সময় গোনার একটি ছোট গোলাকৃতি ভুল, যা system যত বেশি সময় টানা চলে তত জমে; প্রায় ১০০ ঘণ্টা চলার পর ভুলটি এক সেকেন্ডের এক-তৃতীয়াংশের কাছাকাছি দাঁড়ায় বলে উল্লেখ করা হয়, যা দ্রুতগামী লক্ষ্যের অবস্থান হিসাবে বড় পার্থক্য আনে। কয়েক মিনিটের কোনো test এই ভুল দেখাতে পারত না।

Software-এ এমন জমতে থাকা সমস্যা অনেক: প্রতিটি অনুরোধে একটু করে বাড়া memory (leak), ফেরত না দেওয়া database connection, বাড়তে থাকা log বা temporary ফাইল, ক্রমশ বড় হওয়া cache, ঘড়ি বা counter-এর overflow. ছোট test-এ এগুলো একটি সমান্তরাল রেখার মতো দেখায়; ঢালটি এত কম যে দশ মিনিটে চোখে পড়ে না, কিন্তু দশ ঘণ্টায় system থামিয়ে দেয়।

Soak test-এর পরিকল্পনায় চাপ সাধারণত স্বাভাবিক মাত্রায় রাখা হয়, কারণ উদ্দেশ্য সময়ের প্রভাব দেখা, সীমা নয়। মাপা হয় শুধু response time নয়: process-এর memory, খোলা connection-এর সংখ্যা, disk-এর ব্যবহার, ভুলের হার, সব সময়ের সাথে। ফল পড়ার পদ্ধতিও আলাদা: শুরুর এক ঘণ্টা আর শেষের এক ঘণ্টার p95 তুলনা, আর memory-র রেখার ঢাল। সময়কাল ঠিক হয় system কতক্ষণ টানা চলে তা দেখে: প্রতি রাতে restart হলে এক দিনের বেশি দরকার নেই, মাসের পর মাস চললে দীর্ঘতর।

এই কোর্সের lab-এ যন্ত্রের বাজেটের কারণে soak test করা হবে কয়েক মিনিটের ছোট রূপে, স্পষ্ট লেবেলসহ (পর্ব ৫০)। ছোট রূপ ঢাল দেখানোর পদ্ধতি শেখায়; আসল নিশ্চয়তা দেয় না।

মূল উপলব্ধি: কিছু ভুল সময়ের সাথে জমে, চাপের সাথে নয়; soak test স্বাভাবিক চাপে দীর্ঘ সময় চলে, আর তার ফল পড়া হয় ঢাল দিয়ে, একটি গড় দিয়ে নয়।

অনুশীলন

উত্তর দেখার আগে কাগজে নিজে করুন।

  1. Spec থেকে performance test ডিজাইন: Product owner বললেন: “ঈদের সেলের রাতে search যেন দ্রুত থাকে। আমাদের হিসাবে চূড়ায় প্রতি সেকেন্ডে ১০টি search আসবে; একজন ক্রেতা দুই search-এর মাঝে গড়ে ২০ সেকেন্ড ফল দেখেন। আর রাত ৯টার ঘোষণার পর কয়েক সেকেন্ডে ভিড় স্বাভাবিকের দশ গুণ হয়।” (ক) একটি testable requirement লিখুন। (খ) Search-এর response time ০.৫ সেকেন্ড ধরলে closed model-এ কতজন VU লাগবে? (গ) কোন কোন ধরনের test, কোন আকারে প্রস্তাব করবেন? (ঘ) Pass/fail-এর শর্ত কী?

    (ক) উদাহরণ: “সেলের চূড়ায় ১০ search/সেকেন্ড চাপে, staging environment-এ, অন্তত ১০ মিনিট ধরে, search-এর p95 ≤ ২ s আর error rate ≤ ১%; ঘোষণার spike-এর পর ২ মিনিটের মধ্যে p95 আবার ≤ ২ s.” কোন environment, কত data, আর “search” মানে কোন endpoint, তাও লিখুন। (খ) Little-এর সূত্রে N = X × (R + Z) = ১০ × (০.৫ + ২০) = ২০৫ জন VU. (গ) Load test: ২০৫ VU, ২০ সেকেন্ড think time, চূড়ায় ধরে রাখা; spike test: স্বাভাবিক চাপ থেকে কয়েক সেকেন্ডে দশ গুণ, তারপর নামা, ফেরার সময় মাপা; stress test: চূড়া ছাড়িয়ে ধাপে ধাপে, knee খোঁজা। প্রতি সেকেন্ডের নির্দিষ্ট হার যাচাইয়ে open model (arrival rate ১০/সেকেন্ড) আরও স্বাভাবিক, কারণ সেলের ক্রেতারা server-এর গতির অপেক্ষা না করেই আসেন। (ঘ) প্রতিটি test-এ p95 আর error rate দুটোই, পর্যাপ্ত নমুনা, warm-up বাদ, আর spike-এর ক্ষেত্রে ফেরার সময়সীমা।

  2. ফল পড়ুন আর অনুমান করুন: একটি load script এই আউটপুট দিল:
    /api/products?q=oil  requests=500 users=50 errors=0
    duration=19.7s  throughput=25.4 req/s
    mean=1875ms  p50=1559ms  p90=2884ms  p95=2894ms  p99=3044ms
    NFR-2 (p95 <= 2000 ms): FAIL
    (ক) গড় ২ সেকেন্ডের কম, তবু FAIL কেন? (খ) Little-এর সূত্রে সংখ্যাগুলো সামঞ্জস্যপূর্ণ কি? (গ) p50 আর p90-এর বড় ফাঁক কী ইঙ্গিত দেয়? (ঘ) Server-এ ৪০টি worker thread থাকলে আর প্রতিটি অনুরোধে ≈ ১.৫ s লাগলে, ৪০ জনে p95 কেমন হবে বলে অনুমান করেন?

    (ক) NFR-2 লেখা p95-এ, গড়ে নয়; ৫% সাড়া ২৮৯৪ ms-এর বেশি, তাই FAIL. গড় দুই দলের মাঝে পড়ে বলে লুকিয়ে যায়। (খ) X × R = ২৫.৪ × ১.৮৭৫ ≈ ৪৭.৬, যা ৫০-এর কাছাকাছি (think time শূন্য, আর client-এর নিজের সামান্য সময় যোগ হয়); সামঞ্জস্যপূর্ণ। (গ) দুই দল: একদল সরাসরি কাজ পায় (≈ ১.৫ s), আরেকদল লাইনে দাঁড়ায় (≈ ২.৯ s); একটি সীমিত সম্পদে saturation, এখানে ৪০টি thread-এর pool. (ঘ) ৪০ জনে সবাই thread পান, কেউ লাইনে দাঁড়ান না, তাই p95 প্রায় ১.৫ s-এর কাছে থাকার কথা। এই পর্বের সত্যিকারের run-এ ৪০ জনে p95 এল ১৫৮২ ms, PASS. ৪০ থেকে ৫০ জনেই লক্ষ্য ভাঙে।

  3. এই load test রিপোর্টে ভুল খুঁজুন: একজন সহকর্মীর রিপোর্ট; অন্তত পাঁচটি সমস্যা খুঁজুন।
    Load test রিপোর্ট — বাজারঘর search
    Tool: নিজের script, আমার ল্যাপটপে, app-ও একই ল্যাপটপে
    চাপ: 5 VU, প্রতিটি অনুরোধের পর sleep(1), 30 সেকেন্ড
    অনুরোধ: GET /api/products?q=oil (প্রতিবার একই)
    ফল: গড় 180 ms, 148টি অনুরোধ
    সিদ্ধান্ত: system 1000 জন একসাথে সামলাতে পারবে। NFR-2 PASS.

    (১) NFR-2 ৫০ জনের কথা বলে, test হয়েছে ৫ জনে: শর্তই মানা হয়নি। (২) শুধু গড়; p95 নেই, তাই NFR-2-এর রায় দেওয়াই যায় না। (৩) ৫ জন থেকে ১০০০ জনের দাবি: extrapolation, যা saturation আর knee উপেক্ষা করে; এই পর্বের run-এ ৪০ থেকে ৫০ জনেই আচরণ বদলেছিল। (৪) Error বা status code-এর কোনো উল্লেখ নেই। (৫) একই অনুরোধ বারবার: cache-এর সুবিধায় অবাস্তব দ্রুত। (৬) ৩০ সেকেন্ড, ১৪৮টি নমুনা: খুব ছোট run, warm-up-এর উল্লেখ নেই, একটিমাত্র run. (৭) sleep(1) think time-এর যুক্তি নেই; Little-এর সূত্রে ৫ জন × (০.১৮ + ১) সেকেন্ডের চক্র ≈ ৪.২ req/s, আসলে ১৪৮ ÷ ৩০ ≈ ৪.৯, তাই সংখ্যাগুলোও যাচাই দরকার। (৮) App আর generator একই ল্যাপটপে, environment-এর বিবরণ ছাড়া production-এর ক্ষমতার দাবি।

  4. কোন ধরনের test: প্রতিটি পরিস্থিতির জন্য সবচেয়ে উপযুক্ত performance test-এর ধরন বলুন, এক লাইনে কারণসহ। (ক) App কয়েক দিন চললে ধীর হয়, restart করলে ঠিক হয়ে যায়। (খ) “সেলের রাতে সর্বোচ্চ কতজন পর্যন্ত লক্ষ্য টেকে?” (গ) টিভিতে বিজ্ঞাপনের ঠিক পরে কয়েক সেকেন্ডে ভিড় দশ গুণ। (ঘ) দ্বিতীয় app server যোগ করলে throughput কতটা বাড়বে? (ঙ) পণ্যের সংখ্যা ১২ থেকে ১০ লাখে গেলে search-এর গতি।

    (ক) Soak test: দীর্ঘ সময়ে memory বা connection জমার সন্দেহ, সময়ের সাথে ঢাল দেখতে হবে। (খ) Stress test (বা capacity test): চাপ ধাপে ধাপে বাড়িয়ে যে ধাপে p95 বা error rate লক্ষ্য ছাড়ায়, সেটি খোঁজা। (গ) Spike test: হঠাৎ ধাক্কা আর তারপর স্বাভাবিকে ফেরা। (ঘ) Scalability test: একই চাপে ১ বনাম ২ server-এর throughput আর p95. (ঙ) Volume test: চাপ স্থির রেখে data বড় করা, যাতে index বা query-র দুর্বলতা ধরা পড়ে।

নিজেকে যাচাই করুন

ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।

ক্রমএকটি performance test-এর প্রক্রিয়ার ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. পরিকল্পনা — লক্ষ্য, workload আর environment ঠিক করা
  2. Script — ব্যবহারকারীর যাত্রা, test data আর উত্তর যাচাই লেখা
  3. Baseline — বর্তমান build-এর মাপ নেওয়া
  4. Run আর বিশ্লেষণ — percentile, error rate আর সম্পদ দেখা
  5. Tuning বা সমাধান — bottleneck দূর করা
  6. আবার run — একই শর্তে মেপে baseline-এর সাথে তুলনা

একটি search endpoint-এর ২০টি সাড়ার সময় (ms), ছোট থেকে বড় সাজানো: 95, 98, 102, 105, 108, 110, 112, 115, 118, 120, 122, 125, 130, 135, 140, 145, 160, 1550, 2900, 3100. Nearest-rank নিয়মে p95 কত?

  • 1550 ms
  • 479.5 ms
  • 2900 ms
  • 3100 ms

একটি online দোকানে সন্দেহ: app কয়েক দিন টানা চললে ধীরে ধীরে memory বাড়ে আর শেষে ধীর হয়ে যায়; restart করলে ঠিক। এটি ধরতে কোন ধরনের performance test সবচেয়ে উপযুক্ত?

  • Spike test
  • Soak test
  • Stress test
  • Volume test

একটি closed-model load test-এ think time Z = 5 s, গড় response time R = 0.2 s, আর লক্ষ্য throughput X = 20 req/s. Little-এর সূত্রে কতজন virtual user লাগবে?

  • 4
  • 100
  • 50
  • 104

একটি load test-এ ৫০ জনে গড় response time 1875 ms আর p95 2894 ms. Requirement: “৫০ জন একসাথে থাকলে p95 ≤ 2 s”. সঠিক সিদ্ধান্ত কোনটি?

  • FAIL, কারণ p95 2 সেকেন্ডের বেশি
  • PASS, কারণ গড় 2 সেকেন্ডের কম
  • রায় দেওয়া যায় না, median লাগবে
  • PASS, কারণ গড় আর p95-এর গড় প্রায় 2.4 s, কাছাকাছি

একটি closed-model load tool প্রতি 10 ms-এ একটি অনুরোধ পাঠাতে চায়। Server 2 সেকেন্ড থেমে যায়; tool সেই সময় উত্তরের অপেক্ষায় বসে থাকে আর নিজের পাঠানোর সময় থেকে latency মাপে। রিপোর্টের p99-এ কী ঘটে?

  • p99 আসলের চেয়ে অনেক বেশি দেখায়
  • p99-এর বদলে error rate বেড়ে যায়
  • p99 আসলের চেয়ে অনেক কম দেখায়, কারণ ধীর সময়ের অনুরোধগুলো মাপই হয়নি
  • p99 একদম নির্ভুল থাকে

একটি load test-এ ১০ জন থেকে ৫০ জনে যেতে throughput 369 থেকে 233 req/s-এ নামল, আর গড় response time 27 থেকে 204 ms-এ উঠল; কোনো error নেই। এটি সবচেয়ে সম্ভবত কী নির্দেশ করে?

  • নেটওয়ার্ক বিচ্ছিন্ন হয়েছে
  • কোনো সম্পদ saturation-এ পৌঁছেছে; বাড়তি ব্যবহারকারী শুধু লাইন লম্বা করছে
  • System দ্রুত হয়েছে, তাই কম অনুরোধ লাগছে
  • Warm-up না করার ফল

“৯৫% অনুরোধ ২ সেকেন্ডের মধ্যে” লক্ষ্যের একটি load test-এর pass/fail শর্তে আর কোনটি অবশ্যই থাকা উচিত, যাতে খারাপ system ভুল করে পাস না করে?

  • গড় response time-এর একটি সীমা
  • সর্বোচ্চ virtual user-এর সংখ্যা
  • Test কতক্ষণ চলবে
  • Error rate-এর সীমা, যেমন ≤ 1%

শব্দকোষ

লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:

মনে রাখুন

  1. ধরন = চাপের আকার: load (প্রত্যাশিত চূড়া), stress (সীমা ছাড়িয়ে), spike (হঠাৎ), soak (দীর্ঘ), scalability (সম্পদ বদলে), volume (বড় data).
  2. মাপকাঠি একসাথে পড়ুন: response time, throughput আর error rate; saturation-এ বাড়তি ব্যবহারকারী শুধু লাইন বাড়ায়।
  3. গড় নয়, percentile: সত্যিকারের run-এ গড় ১৮৭৫ ms, p95 ২৮৯৪ ms; NFR-2 FAIL. Percentile-এর গড় করবেন না।
  4. Workload লিখে বলুন: VU, think time, closed না open; N = X × (R + Z) দিয়ে সংখ্যা মিলিয়ে দেখুন।
  5. শর্তসহ test: warm-up, যথেষ্ট নমুনা, error rate, environment-এর বিবরণ; আর coordinated omission থেকে সাবধান।

পরের পর্বে: Locust দিয়ে load test — Python-এ বাজারঘরের ক্রেতার যাত্রা লেখা, task-এর ভার আর wait time, headless run, CSV রিপোর্ট থেকে endpoint-ভিত্তিক p95, আর ধাপে ধাপে চাপ বাড়িয়ে knee খোঁজা।

আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ

এই পর্বটি শেয়ার করুন:
এই পর্বে ভুল পেয়েছেন? জানান