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

Bottleneck খোঁজা — profiling, query আর resource

Finding Performance Bottlenecks — Profiling, Queries and Resources

Taught in Bangla, this lesson moves from a slow load test to the cause with USE and RED. In a real lab an order list on a 40,000 order copy shows p95 4700 ms and 182 queries per request. py-spy puts 97 percent of samples on one query line, cProfile counts 915 executes, and EXPLAIN QUERY PLAN shows a table scan, revealing N+1 queries and a missing index. After two indexes and three queries p95 falls to 74 ms with the functional tests still passing, and a query-count limit guards regressions.

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

  • Bottleneck কী, আর load test-এর “ধীর” ফল থেকে কারণ খোঁজার শৃঙ্খলাবদ্ধ পথ
  • USE আর RED পদ্ধতি দিয়ে resource আর service-এর অবস্থা পড়া
  • cProfile (deterministic) আর py-spy (sampling) দিয়ে Python-এর hot spot খোঁজা, আর flame graph পড়া
  • EXPLAIN QUERY PLAN, missing index আর N+1 query চেনা ও সারানো
  • “সারানো → একই load-এ আবার মাপা”-র নিয়ম, আর query-সংখ্যার সীমা দিয়ে regression আটকানো

১ · Bottleneck কী — ফেরিঘাটের সবচেয়ে সরু জায়গা

ঈদের আগে ঢাকা থেকে দক্ষিণবঙ্গে যাওয়ার পুরোনো দিনের কথা ভাবুন। মহাসড়ক চার লেন, বাস দ্রুত চলে, কিন্তু ফেরিঘাটে এসে সব থামে। ফেরি একবারে যতগুলো গাড়ি নেয়, তার চেয়ে বেশি গাড়ি এলে সারি লম্বা হয়। এখন মহাসড়ক আট লেন করলে কী হবে? কিছুই না, শুধু ঘাটে সারি আরও দ্রুত লম্বা হবে। পুরো যাত্রার গতি ঠিক করছে ঘাট, রাস্তা নয়। এই ঘাটই bottleneck: বোতলের গলার মতো সবচেয়ে সরু জায়গা, যা দিয়ে সব কিছুকে যেতে হয়।

Software-এ ঘাটটি হতে পারে CPU, একটি database query, একটি lock, পূর্ণ connection pool, ধীর disk, বাইরের একটি payment service, বা এমনকি log লেখা। দুটি সত্য মনে রাখুন। প্রথম, যে কোনো মুহূর্তে সাধারণত একটি জায়গাই প্রধান সীমা টানে; অন্য জায়গা দ্রুত করলে লাভ প্রায় শূন্য। দ্বিতীয়, একটি bottleneck সারালে পরেরটি সামনে আসে, যেমন ঘাটে সেতু হলে এবার যানজট টোলপ্লাজায়। তাই কাজটি একবারের নয়, একটি চক্র।

মডিউল ৮-এর আগের তিন পর্বে আপনি শিখেছেন কতটা ধীর তা মাপতে: পর্ব ৪৬-এ percentile আর load-এর ধরন, পর্ব ৪৭ আর ৪৮-এ Locust আর k6. সেই মাপ বলে “p95 লক্ষ্যের বাইরে”, কিন্তু বলে না কেন। এই পর্বের কাজ সেই “কেন”: প্রমাণ দিয়ে ঘাটটি খুঁজে বের করা, সারানো, আর একই মাপে প্রমাণ করা যে সত্যিই সেরেছে। Tester হিসেবে আপনার ভূমিকা সাধারণত পুরো সমাধান লেখা নয়; কিন্তু “অর্ডার পাতা ধীর” রিপোর্টের বদলে “এই endpoint-এ প্রতি request-এ ১৮২টি query, যার একটি পুরো টেবিল পড়ে” রিপোর্ট দিলে developer-এর কাজ ঘণ্টা থেকে মিনিটে নামে।

বাজারের উপমা: কারওয়ান বাজারে এক দোকানে ভিড়। মালিক ভাবলেন, “আরও দুজন বিক্রেতা রাখি।” কিন্তু দেখা গেল সবাই একটিই দাঁড়িপাল্লা ভাগ করে ব্যবহার করে। বিক্রেতা বাড়ালে দাঁড়িপাল্লার সামনে সারি বাড়ে, বিক্রি নয়। আগে দেখতে হবে কোন জিনিসটি সবসময় ব্যস্ত আর কোথায় মানুষ অপেক্ষা করছে। এই দুটি প্রশ্নই পরের অংশের USE পদ্ধতির মূল।

Latency, throughput আর percentile-এর তাত্ত্বিক ভিত্তি সিস্টেম ডিজাইন কোর্সের পর্ব ০৪-এ আছে; এখানে সেগুলো ব্যবহার করব, নতুন করে শেখাব না।

২ · USE আর RED — অনুমানের বদলে চেকলিস্ট

ধীর system দেখলে মানুষের প্রথম প্রবৃত্তি হলো পরিচিত সন্দেহভাজনকে দোষ দেওয়া: “নিশ্চয়ই database-এর দোষ”, “নিশ্চয়ই network-এর দোষ”। Brendan Gregg এই অভ্যাসকে বলেছেন “streetlight” পদ্ধতি: চাবি হারিয়েছে অন্ধকারে, কিন্তু খোঁজা হচ্ছে ল্যাম্পপোস্টের নিচে, কারণ সেখানে আলো আছে। তার বিকল্প হিসেবে তিনি USE method প্রস্তাব করেন (২০১২ সালের দিকে ACM Queue-এর একটি প্রবন্ধে, আমাদের জানা মতে)। নিয়মটি সরল: প্রতিটি resource-এর জন্য তিনটি প্রশ্ন।

  • U, Utilization: resource-টি কত সময় ব্যস্ত ছিল (যেমন CPU ৯৮%)?
  • S, Saturation: কত কাজ অপেক্ষায় আছে, যা resource এখনই নিতে পারছে না (run queue, অপেক্ষমাণ request)?
  • E, Errors: resource কি ভুল বা ব্যর্থতা দিচ্ছে (timeout, connection refused, disk error)?

অন্য দিক থেকে দেখে Tom Wilkie (২০১৫ সালের দিকে, microservice পর্যবেক্ষণের প্রেক্ষাপটে) প্রস্তাব করেন RED method: প্রতিটি service বা endpoint-এর জন্য Rate (প্রতি সেকেন্ডে কতগুলো request), Errors (কতগুলো ব্যর্থ), Duration (কত সময়, percentile-এ)। USE দেখে যন্ত্রের ভেতরটা, RED দেখে ব্যবহারকারী যা অনুভব করেন। Google-এর SRE বইয়ের (২০১৬) four golden signals (latency, traffic, errors, saturation) দুটির মাঝামাঝি। Linux-এর যন্ত্র দিয়ে USE-এর পূর্ণ চর্চা অপারেটিং সিস্টেম কোর্সের পর্ব ৫৭-এ; এখানে আমরা দেখব একজন tester কীভাবে load test চলার সময়ই এটি কাজে লাগান।

ResourceUtilizationSaturationErrors
CPU (app process)process-এর CPU %অপেক্ষমাণ request, run queue—
App-এর thread poolব্যস্ত thread / মোটthread-এর জন্য সারিতে থাকা requestরিজেক্ট হওয়া কাজ
Memoryprocess-এর memory (RSS)swap, GC-র থামাout-of-memory
Disk / filedisk ব্যস্ততা, পড়া-লেখার পরিমাণdisk-এর সারিI/O error
DB connection poolব্যবহৃত connectionconnection-এর অপেক্ষাpool timeout
Lock (যেমন বাজারঘরের লেখার lock)lock ধরা থাকার সময়lock-এর অপেক্ষায় threaddeadlock, busy timeout
বাইরের service (wallet)চলমান callঅপেক্ষমাণ call504, decline

একটি সূক্ষ্মতা: utilization ১০০%-এর কাছে গেলে latency লাফিয়ে বাড়ে, কারণ সারি তৈরি হয়। তাই শুধু “CPU ৭০%” দেখে নিশ্চিন্ত হওয়া যায় না, saturation-ও দেখতে হয়। আর errors সবচেয়ে সহজে চোখ এড়ায়: একটি resource ভুল দিয়ে দ্রুত ফেরত দিলে latency ভালো দেখায়, যদিও কাজ হয়নি। পরের অংশের সত্যিকারের run থেকে নেওয়া মান দিয়ে বাজারঘরের ওপর USE-এর একটি পূর্ণ চক্র দেখুন:

GET /api/orders · ১০ জন · ৩২ s · app-এ ২টি thread
Resource
U
S
E
সিদ্ধান্ত
  1. আগে তালিকা। Run শুরুর আগেই ঠিক করুন কোন resource দেখবেন। বাজারঘর SQLite ব্যবহার করে, যা আলাদা server নয়, app-এর process-এর ভেতরেই চলে; তাই “database-এর CPU” আলাদা নেই, সবই app process-এর CPU.
  2. CPU. App-কে ২টি thread-এ সীমিত রাখা হয়েছিল (ছোট একটি ২-core server-এর মতো, আর ল্যাপটপের অন্য কাজের প্রতি সদয়)। গড় ১৯৫%, সর্বোচ্চ ২০০%: দুটি thread পুরো সময় ব্যস্ত। Utilization প্রায় ১০০%.
  3. Saturation. ১০ জন ব্যবহারকারী একসাথে request পাঠান, কিন্তু একসাথে কাজ হয় মাত্র ২টি। বাকিরা সারিতে। একটি request-এর নিজের কাজ প্রায় ০.৫–০.৭ সেকেন্ড, কিন্তু সারির কারণে ব্যবহারকারী অপেক্ষা করেন ৩–৪ সেকেন্ড।
  4. Memory. সর্বোচ্চ ৬৩ MB, স্থির। Memory সমস্যা নয়; swap এই run-এ মাপা হয়নি, সৎভাবে লিখে রাখা দরকার।
  5. File reads: সূত্র! ৩২ সেকেন্ডে process ফাইল থেকে প্রায় ৫২ হাজার MB পড়তে চেয়েছে, ১০১টি request-এ, মানে প্রতি request-এ প্রায় ৫১৪ MB, অথচ পুরো database ফাইল প্রায় ২১ MB. এর বেশির ভাগ সম্ভবত operating system-এর memory cache থেকে এসেছে, disk থেকে নয়; কিন্তু একই page বারবার পড়া হচ্ছে, এটাই আসল খবর।
  6. RED আর সিদ্ধান্ত। Rate ৩.১ req/s, Errors ০, Duration p95 ৪৪০৪ ms: NFR-2-এর ২ সেকেন্ড থেকে অনেক দূরে, তাও ৫০ নয়, মাত্র ১০ জনে। USE বলছে: CPU ভরা, আর সেই CPU একই data বারবার পড়ছে। পরের প্রশ্ন: কোন code পড়ছে? উত্তর দেবে profiler.

৩ · সত্যিকারের ল্যাব — volume data-য় ধীর অর্ডার তালিকা

নিচের সব run এই কোর্স লেখার সময় সত্যিকারভাবে চালানো। App: কোর্সের বাজারঘর (MIT), নিজের একটি কপি, শুধু 127.0.0.1:8824-এ, নিজের database ফাইলে। যন্ত্র: Python 3.12.13, uvicorn 0.54.0 (BSD-3-Clause), SQLite 3.50.4 (public domain); load-এর জন্য httpx 0.28.1 (BSD-3-Clause) দিয়ে লেখা একটি ছোট script, resource মাপার জন্য psutil 7.2.2 (BSD-3-Clause), আর profiler py-spy 0.4.3 (MIT). সবচেয়ে জরুরি সতর্কতা: একই ল্যাপটপে app আর load generator, আর সেই সময় একই যন্ত্রে অন্য কাজও চলছিল। তাই সংখ্যাগুলো আকৃতি আর তুলনা দেখায়, production-এর ক্ষমতা নয়। প্রতিটি run ছোট (১০ বা ৫০ জন, ৩০ সেকেন্ড), শুধু নিজের app-এর ওপর।

কেন volume data?

বাজারঘরের seed data-য় joy-র মাত্র ২টি অর্ডার, পুরো দোকানে ৭টি। সেই data-য় joy-র অর্ডার তালিকা (GET /api/orders) আনতে লাগে প্রায় ১.০ ms, ৭টি query-তে। কোনো functional test এখানে কিছু ধরবে না, ধরার কথাও নয়। কিন্তু এক বছর চলার পর দোকানে হাজার হাজার অর্ডার থাকবে। সেই অবস্থা আগেই তৈরি করে দেখার নাম volume testing: বড় data-র ওপর একই কাজ। একটি script (make_volume.py, seed নির্দিষ্ট) কপিতে ৫০০ জন কাল্পনিক ক্রেতা আর ৪০ হাজার delivered অর্ডার যোগ করল, joy-র মোট ৬০টি:

$ uv run python make_volume.py lab.db
users              505 rows
orders           40007 rows
order_items      80013 rows
order_history   200027 rows
joy's orders   60

Server-Timing — server নিজেই বলুক কোথায় সময় গেল

কপিতে একটি ছোট middleware যোগ করা হলো, যা প্রতিটি উত্তরে Server-Timing header বসায়। এটি W3C-র একটি মানক header, যেখানে server নিজের ভেতরের সময় আর বিবরণ জানাতে পারে; browser-এর DevTools-এর Network ট্যাবেও তা দেখা যায়। আমাদের middleware মোট সময় আর SQL statement-এর সংখ্যা জানায় (সংখ্যা গোনে sqlite3-এর trace callback):

@app.middleware("http")
async def server_timing(request, call_next):
    stats = {"n": 0}
    token = db.QSTATS.set(stats)     # db.connect() adds a trace callback
    t0 = time.perf_counter()         # that does stats["n"] += 1 per SQL
    response = await call_next(request)
    ms = (time.perf_counter() - t0) * 1000
    db.QSTATS.reset(token)
    response.headers["Server-Timing"] = (
        f'app;dur={ms:.1f}, db;desc="{stats["n"]} queries"')
    return response

Load script-টি ইচ্ছা করে সরল: ১০ জন “ব্যবহারকারী” (asyncio task), প্রত্যেকে joy হিসেবে login করে ৩০ সেকেন্ড ধরে একটির পর একটি GET /api/orders পাঠান, কোনো বিরতি (think time) ছাড়া। প্রথম ৩টি request warm-up, মাপে ধরা হয় না। শেষে p50/p95/p99 (nearest-rank পদ্ধতি), throughput আর server process-এর CPU. একই কাজ Locust বা k6 দিয়েও করা যায় (পর্ব ৪৭, ৪৮); এখানে script ছোট রাখা হয়েছে যাতে load-এর সাথে psutil দিয়ে server-এর resource একসাথে মাপা যায়। মূল অংশ:

async def user(client, token, stop, lat, errs):
    while time.perf_counter() < stop:          # closed model, no think time
        t0 = time.perf_counter()
        r = await client.get("/api/orders",
                             headers={"Authorization": f"Bearer {token}"})
        lat.append((time.perf_counter() - t0) * 1000)
        errs[0] += r.status_code != 200

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

বাজারঘরের endpoint-গুলো সাধারণ (sync) Python function, তাই FastAPI প্রতিটি request একটি thread pool-এ চালায়; ডিফল্টে সেই pool-এ ৪০টি thread. পর্ব ৪৬-এ দেখেছেন, slow_search চালু থাকলে ৫০ জনে ঠিক এই ৪০-এর সীমাতেই ১০টি request সারিতে দাঁড়ায় আর p95 লাফ দেয়: pool নিজেই একটি bottleneck, USE-এর ভাষায় saturation. আমাদের ল্যাবে app চালানো হলো LAB_THREADS=2 দিয়ে (কপির একটি সেটিং, যা pool দুটি thread-এ নামায়)। প্রথম চেষ্টায় ডিফল্ট ৪০ রেখে চালানো হয়েছিল, তখন SQLite-এর query-গুলো সমান্তরালে চলে ল্যাপটপের অনেকগুলো core-এর সমান CPU খেয়ে ফেলে; অন্যদের কাজের ক্ষতি এড়াতে সেটি থামিয়ে সীমা বসানো হয়, যা একটি ছোট ২-core server-এর মতো। সত্যিকারের আউটপুট:

$ LAB_THREADS=2 uv run bazarghar --port 8824 --db lab.db
$ uv run python load.py 8824 10 30 before <server-pid>
[before] 10 users, 32 s, orders/resp=60
  requests=95 errors=0 throughput=2.9 req/s
  p50=3323 ms  p95=4700 ms  p99=4721 ms  max=4721 ms  mean=3274 ms
  Server-Timing: app;dur=571.3, db;desc="182 queries"
  server process CPU: mean 195% of one core (max 200%)

লক্ষণ পরিষ্কার। মাত্র ১০ জনে p95 ৪.৭ সেকেন্ড; NFR-2 (পর্ব ১৫: ৫০ জন একসাথে, p95 ≤ ২ সেকেন্ড) ১০ জনেই ভাঙছে। আর Server-Timing একটি অদ্ভুত সংখ্যা দেখাচ্ছে: একটি request-এ ১৮২টি query, ৬০টি অর্ডার দেখাতে। একটি query-র হিসাব সহজ: token থেকে ব্যবহারকারী খোঁজা। বাকি ১৮১টি? এখনই উত্তর দেবেন না; profiler-কে বলতে দিন। কিছুক্ষণ পরে একই অবস্থায় আরেকবার চালিয়ে p95 পাওয়া গেল ৪৪০৪ ms (উপরের stepper সেই run-এর)। দুটি run-এর পার্থক্য প্রায় ৬%: একই কোড, একই data, শুধু ল্যাপটপের অন্য কাজের ব্যস্ততা আলাদা। এই শব্দ (noise) মনে রাখুন; পর্ব ৪০-এর পরিসংখ্যান এখানেও খাটে।

৪ · Profiling — cProfile আর py-spy দিয়ে hot spot খোঁজা

Profiler হলো এমন যন্ত্র, যা প্রোগ্রাম চলার সময় মাপে সময় কোথায় যাচ্ছে। দুই ধরনের profiler আছে, আর পার্থক্যটি পরীক্ষা ও ইন্টারভিউতে প্রায়ই আসে।

Deterministic (instrumenting)

Deterministic profiler প্রতিটি function-এ ঢোকা আর বেরোনো গোনে। ফল নিখুঁত গণনা (ncalls), কিন্তু প্রতিটি call-এ বাড়তি খরচ, তাই ছোট ছোট function বেশি থাকলে সময় বিকৃত হয়। Python-এর stdlib-এর cProfile এই ধরনের।

Sampling

Sampling profiler নিয়মিত বিরতিতে (যেমন সেকেন্ডে ১০০ বার) দেখে প্রতিটি thread তখন কোন stack-এ আছে। গণনা নেই, অনুপাত আছে; খরচ কম, আর চলমান process-এ কোড না বদলেই লাগানো যায়। py-spy এই ধরনের।

cProfile-এর মূল ব্যবহার Python প্রোগ্রামিং কোর্সের পর্ব ৪৬-এ শেখানো হয়েছে। এখানে প্রশ্নটি tester-এর: ধীর endpoint-এর পথটি কীভাবে আলাদা করে profile করবেন, আর ফল পড়ে কীভাবে অনুমান বানাবেন।

cProfile — শুধু ধীর পথটি, load ছাড়া

পুরো server-কে cProfile-এর নিচে চালালে event loop, middleware আর হাজার জিনিস মিশে যায়। তার চেয়ে ভালো: ধীর কাজটিকে সরাসরি ডাকা। একটি ছোট script একই database-এ Shop.orders(joy) একবার warm-up করে, তারপর ৫ বার cProfile-এর নিচে চালায় (পূর্ণ path ছেঁটে strip_dirs()), সত্যিকারের আউটপুট:

$ uv run python profile_orders.py lab.db
         6546 function calls (6526 primitive calls) in 2.723 seconds

   Ordered by: internal time
   List reduced from 35 to 6 due to restriction <6>

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
      605    1.397    0.002    1.397    0.002 {method 'fetchall' of 'sqlite3.Cursor' objects}
      915    1.309    0.001    1.309    0.001 {method 'execute' of 'sqlite3.Connection' objects}
      300    0.004    0.000    0.009    0.000 services.py:286(_order_dict)
        5    0.003    0.001    0.003    0.001 {method 'close' of 'sqlite3.Connection' objects}
     1790    0.002    0.000    0.002    0.000 rules.py:89(__init__)
     1800    0.002    0.000    0.004    0.000 rules.py:94(next_status)

tottime হলো function-এর নিজের ভেতরে কাটানো সময় (ভেতর থেকে ডাকা অন্য function বাদে), আর cumtime সবকিছুসহ। দুটি সারি মিলে ২.৭০৬ সেকেন্ড, মোট ২.৭২৩-এর ৯৯%-এর বেশি: সময় যাচ্ছে SQLite-এর C কোডে, Python-এ নয়। কিন্তু আসল সূত্র সময় নয়, সংখ্যা: ৫ বার ডাকায় execute ৯১৫ বার, অর্থাৎ প্রতি ডাকে ১৮৩টি। তার ২টি connection খোলার PRAGMA, বাকি ১৮১টি query: ৬০টি অর্ডারের প্রতিটির জন্য ৩টি, আর তালিকার জন্য ১টি। এই আকৃতির নাম আছে, পরের অংশে দেখবেন। cProfile-এর সীমাও দেখুন: সব query একই execute সারিতে মিশে গেছে, কোনটি ধীর তা বলে না।

py-spy — চলমান server-এ, load-এর মধ্যেই

py-spy (Rust-এ লেখা, MIT লাইসেন্স) uv-এর venv-এ সাধারণ uv add --dev py-spy দিয়ে নির্বিঘ্নে বসেছে, আর Windows-এ নিজের চালানো process-এ admin অধিকার ছাড়াই কাজ করেছে। Load script আবার চালু রেখে, তার মাঝখানে server-এর process-এ ১৫ সেকেন্ড নমুনা নেওয়া হলো, সত্যিকারের আউটপুট:

$ uv run py-spy record --pid <server-pid> --duration 15 --rate 100 \
      --format raw -o before.folded
py-spy> Sampling process 100 times a second for 15 seconds. Press Control-C to exit.
py-spy> Wrote raw flamegraph data to 'before.folded'. Samples: 2747 Errors: 0

$ python folded_lines.py before.folded      # which source line was on top?
samples: 2747
 51.2%   1406  Shop._order  services.py:283
 45.9%   1261  Shop._order  services.py:282
  1.0%     28  Shop.orders  services.py:243
  0.5%     14  Shop._order  services.py:277
  0.2%      6  Shop._order  services.py:278

--format raw প্রতিটি আলাদা stack আর তার নমুনা-সংখ্যা লেখে (collapsed stack); folded_lines.py নামের ১৫ লাইনের একটি script গুনেছে কোন source লাইন stack-এর মাথায় ছিল। কপির services.py-এর ২৮২–২৮৩ নম্বর লাইন একটিই statement: SELECT status, at FROM order_history WHERE order_id = ? ORDER BY id. দুটি মিলে ৯৭.১% নমুনা। একটি query-ই প্রায় সব সময় খাচ্ছে। (Python-এ C কোডের ভেতরের সময় যে Python লাইন C-কে ডেকেছে, তার নামে গোনা হয়; তাই SQLite-এর কাজও এই লাইনে।) Load-এর এই run-এ p95 ছিল ৩৯৭৪ ms; profiler লাগানো অবস্থাতেও আচরণ প্রায় একই, sampling-এর খরচ যে কম, তার একটি ইঙ্গিত।

Flame graph — একই data, ছবিতে

Flame graph (Brendan Gregg, ২০১১ সালের দিকে) collapsed stack-কে ছবি বানায়: প্রতিটি আয়তক্ষেত্র একটি function, প্রস্থ = মোট নমুনার কত অংশে সেটি stack-এ ছিল, আর নিচের স্তর ওপরের স্তরকে ডাকে (এখানে ওপর থেকে নিচে আঁকা, যাকে icicle বলে)। X-অক্ষ সময় নয়, বর্ণানুক্রম; শুধু প্রস্থ পড়ুন। নিচের ছবিটি আমাদের দুটি সত্যিকারের py-spy run-এর অনুপাতে হাতে আঁকা, সরলীকৃত:

বাজারঘরের অর্ডার তালিকা — profile, সারানোর আগে ও পরে

প্রস্থ = নমুনার অংশ; ওপরে সারানোর আগে (২৭৪৭ নমুনা), নিচে পরে (২১৬৬ নমুনা)

সারানোর আগে একটি query প্রায় পুরো profile; পরে সময় ছড়ানো সারানোর আগে সারানোর পরে all samples · 100% worker thread · 99.4% Shop.orders · 99.1% Shop._order (N+1 loop) · 97.9% order_history query · 97.1% all samples · 100% Shop.orders 56.7% loop 21% token orders items history নিচের সারি: orders 15.1%, items 12.0%, history 14.9%; token খোঁজা 11.7%; বাকি ~10% আগে একটি লাল দণ্ড; পরে কোনো একক hot spot নেই
ছবি ৪৯.১ — সারানোর আগে প্রায় পুরো প্রস্থ একটিই query (লাল): এটাই hot spot. পরে সময় কয়েক জায়গায় ছড়ানো; এমন profile মানে “সহজ বড় লাভ শেষ”।

এবার নিজে একটি profile চালিয়ে দেখুন। নিচের Python (Pyodide) ব্রাউজারেই চলে। এতে একই ধরনের ভুল ছোট আকারে: ৪০০০টি অর্ডার, প্রতিটির ৫টি ইতিহাস-সারি, আর ক্রেতা ৫-এর ১২১টি অর্ডার। প্রথমে দুটি সংস্করণ profiler ছাড়া মাপা হয়, তারপর cProfile-এর নিচে। প্রথম সংস্করণ প্রতিটি অর্ডারের জন্য পুরো ইতিহাস-তালিকা খোঁজে (index ছাড়া query-র মতো), দ্বিতীয়টি একবার পড়ে একটি dict বানায় (index-এর মতো):

import cProfile, pstats, sys, time

# 4000 orders; customer 5 owns every 33rd one (121); 5 history rows each
ORDERS = [(oid, 5 if oid % 33 == 0 else 6) for oid in range(1, 4001)]
STEPS = ("placed", "paid", "packed", "shipped", "delivered")
HISTORY = [(oid, st) for oid, _ in ORDERS for st in STEPS]

def history_scan(order_id):          # like WHERE order_id = ? with NO index
    return [st for oid, st in HISTORY if oid == order_id]

def orders_n_plus_1(user):           # 1 list + 1 scan per order
    return {oid: history_scan(oid) for oid, u in ORDERS if u == user}

def orders_grouped(user):            # one pass builds a dict: an "index"
    by_order = {}
    for oid, st in HISTORY:
        by_order.setdefault(oid, []).append(st)
    return {oid: by_order[oid] for oid, u in ORDERS if u == user}

for f in (orders_n_plus_1, orders_grouped):     # plain timing first
    t0 = time.perf_counter(); f(5)
    print(f"{f.__name__:16} {(time.perf_counter() - t0) * 1000:6.1f} ms, no profiler")
prof = cProfile.Profile()
prof.enable()
slow = orders_n_plus_1(5)
fast = orders_grouped(5)
prof.disable()
print(len(slow), "orders; same result:", slow == fast)
stats = pstats.Stats(prof, stream=sys.stdout).strip_dirs()
stats.sort_stats("tottime").print_stats(4)

আসল আউটপুট (ব্রাউজারের Python; সময়ের ঘরগুলো প্রতিবার একটু বদলায়):

orders_n_plus_1    42.1 ms, no profiler
orders_grouped      4.7 ms, no profiler
121 orders; same result: True
         40124 function calls in 0.112 seconds

   Ordered by: internal time
   List reduced from 6 to 4 due to restriction <4>

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
      121    0.075    0.001    0.075    0.001 main.py:8(history_scan)
        1    0.020    0.020    0.036    0.036 main.py:14(orders_grouped)
    20000    0.009    0.000    0.009    0.000 {method 'setdefault' of 'dict' objects}
    20000    0.008    0.000    0.008    0.000 {method 'append' of 'list' objects}

দুটি সংস্করণ একই ফল দেয় (same result: True), তাই তুলনাটি ন্যায্য। Profiler ছাড়া N+1 সংস্করণ ৪২.১ ms, dict-এর সংস্করণ ৪.৭ ms: প্রায় ৯ গুণ পার্থক্য। Profile-এ history_scan-এর ncalls ১২১, ঠিক ক্রেতার অর্ডারের সংখ্যা: N+1-এর চিহ্ন, ল্যাবের ১৮১টি query-র মতো। আর tottime-এ সেটিই সবার ওপরে। এবার একটি সূক্ষ্ম জিনিস দেখুন: profiler চালু থাকায় dict-এর সংস্করণ ৪.৭ থেকে ৩৬ ms (cumtime) হয়ে গেছে, প্রায় ৮ গুণ; N+1 সংস্করণ ৪২ থেকে ৭৫ ms, দুই গুণেরও কম। কারণ dict-এর সংস্করণে ৪০ হাজার ছোট method call (setdefault, append), আর deterministic profiler প্রতিটি call-এ নিজের খরচ যোগ করে; list comprehension-এর ভেতরে কোনো function call নেই। Profile-এ দুটির পার্থক্য তাই আসলের চেয়ে অনেক ছোট দেখায়। এটাই observer effect: hot spot চিনতে profile ভালো, কিন্তু “কত গুণ দ্রুত” মাপতে profiler ছাড়া আলাদা মাপ নিন। Pyodide-এ file-এর নাম main.py দেখায়; সময়ের সংখ্যা প্রতিবার আর প্রতিটি কম্পিউটারে আলাদা হবে, ncalls হবে না।

মোট৫ বার Shop.orders
6546 function calls in 2.723 seconds
→ প্রতি ডাকে ≈ 545 ms
   (Server-Timing: 571 ms ✓)
tottime অনুযায়ীকোথায় সময়
1.397  fetchall  (sqlite3)
1.309  execute   (sqlite3)
0.004  _order_dict  ← Python
2.706 / 2.723 = 99% SQLite-এ
ncallsকতবার
execute  915 ÷ 5 = 183 প্রতি ডাকে
  − 2 PRAGMA = 181
  = 1 + 60 × 3   ← N+1 আকৃতি
py-spyকোন লাইন
51.2%  services.py:283
45.9%  services.py:282
→ একই statement: 97.1%
SELECT … FROM order_history
 WHERE order_id = ?
অনুমানপরীক্ষাযোগ্য
H1: order_history-তে order_id-এর
    index নেই → প্রতিবার পুরো টেবিল
H2: N+1 সেই খরচকে ৬০ গুণ করে
পরীক্ষা: EXPLAIN QUERY PLAN
  1. মোট দিয়ে শুরু। ৫ বার ডাকায় ২.৭২৩ সেকেন্ড, প্রতিবার প্রায় ৫৪৫ ms. Server-Timing-এর ৫৭১ ms-এর কাছাকাছি, তাই profile যে আসল সমস্যাটিই ধরেছে, তা নিশ্চিত। প্রথম ধাপ সবসময় এই মিলিয়ে দেখা।
  2. tottime: কোথায়। দুটি SQLite method মিলে ৯৯%; Python-এর নিজের কোড (_order_dict) মাত্র ০.০০৪ সেকেন্ড। Python কোড দ্রুত করার চেষ্টা (যেমন dict বানানো বদলানো) এখানে সময় নষ্ট।
  3. ncalls: কতবার। প্রতি ডাকে ১৮৩টি execute, তার ১৮১টি query, ঠিক ১ + ৬০ × ৩. Query-র সংখ্যা অর্ডারের সংখ্যার সাথে বাড়ছে: এটাই N+1-এর চিহ্ন। Deterministic profiler-এর গণনা এখানে সবচেয়ে কাজের।
  4. py-spy: কোন লাইন। ৩টি query-র মধ্যে কোনটি ধীর, cProfile বলতে পারেনি। Sampling profiler লাইন নম্বর দেখায়: ইতিহাসের query একাই ৯৭.১%. অর্ডার আর item-এর query দুটি প্রায় শূন্য।
  5. অনুমান লেখা। “ইতিহাসের টেবিলে order_id-এর index নেই, তাই প্রতিটি query পুরো টেবিল পড়ে; N+1 সেটিকে প্রতি request-এ ৬০ বার করায়।” অনুমানটি যাচাইযোগ্য, আর যাচাইয়ের যন্ত্র query plan; পরের অংশ।

৫ · Query-র ভেতরে — EXPLAIN QUERY PLAN, index আর N+1

Database একটি প্রশ্নের উত্তর কোন পথে খুঁজবে, সেই পরিকল্পনার নাম query plan. SQLite-এ EXPLAIN QUERY PLAN query না চালিয়েই পরিকল্পনাটি দেখায়। দুটি শব্দ চিনলেই শুরু করা যায়: SCAN মানে পুরো টেবিল সারি ধরে ধরে পড়া (full table scan), আর SEARCH … USING INDEX মানে index ধরে সোজা জায়গায় যাওয়া। Index-এর গঠন (B+ tree) DBMS ও SQL কোর্সের পর্ব ৪০-এ; এখানে tester-এর চোখে শুধু প্রমাণ।

ল্যাবের database-এ (Python-এর sqlite3, SQLite 3.50.4) তিনটি query-র plan আর গড় সময় (২০ বারের গড়), সত্যিকারের আউটপুট, ছাঁটা:

SELECT id FROM orders WHERE user_id = ? ORDER BY id DESC
    (3, 0, 216, 'SCAN orders')                                   4.481 ms
SELECT i.product_id, … FROM order_items i JOIN products p … WHERE i.order_id = ?
    (5, 0, 62, 'SEARCH i USING INDEX sqlite_autoindex_order_items_1 (order_id=?)')
    (12, 0, 45, 'SEARCH p USING INTEGER PRIMARY KEY (rowid=?)')  0.008 ms
SELECT status, at FROM order_history WHERE order_id = ? ORDER BY id
    (3, 0, 216, 'SCAN order_history')                            8.725 ms

অনুমান নিশ্চিত। Item-এর টেবিলে (order_id, product_id) primary key আছে, তাই SQLite নিজে থেকেই একটি index বানিয়েছে (sqlite_autoindex_…), আর সেই query ০.০০৮ ms-এ শেষ। ইতিহাসের টেবিলে order_id-এর কোনো index নেই: দুই লাখ সারি পড়ে ৮.৭ ms. ৬০ বার × ৮.৭ ms ≈ ৫২০ ms, ঠিক প্রতি request-এর সময়। আর অর্ডারের টেবিলে user_id-ও index-হীন: ৪.৫ ms, প্রতি request-এ একবার। দুটিই আসল app-এর schema-য় সত্যিই নেই; seed data-য় ৭টি অর্ডারে কেউ টের পায়নি।

নিজে দেখুন। নিচের SQL ব্রাউজারের SQLite-এ চলে; নমুনা ডেটাবেসে একই দুটি টেবিলের ছোট রূপ (২০০০টি অর্ডার, ১০ হাজার ইতিহাস-সারি):

-- 1) before: the two lookups of the N+1 path
EXPLAIN QUERY PLAN SELECT id FROM orders WHERE user_id = 5 ORDER BY id DESC;
EXPLAIN QUERY PLAN
SELECT status, at FROM order_history WHERE order_id = 33 ORDER BY id;

-- 2) the fix, as a migration would do it
CREATE INDEX idx_orders_user ON orders(user_id);
CREATE INDEX idx_history_order ON order_history(order_id);

-- 3) after: same queries, plus the batched join (one query for all 60)
EXPLAIN QUERY PLAN SELECT id FROM orders WHERE user_id = 5 ORDER BY id DESC;
EXPLAIN QUERY PLAN
SELECT status, at FROM order_history WHERE order_id = 33 ORDER BY id;
EXPLAIN QUERY PLAN
SELECT h.order_id, h.status FROM order_history h
  JOIN orders o ON o.id = h.order_id
 WHERE o.user_id = 5 ORDER BY h.id;
SELECT COUNT(*) AS joy_orders FROM orders WHERE user_id = 5;

আসল আউটপুট (ব্রাউজারের SQLite), প্রতিটি টেবিলের detail কলাম:

SCAN orders
SCAN order_history
✓ CREATE INDEX
✓ CREATE INDEX
SEARCH orders USING COVERING INDEX idx_orders_user (user_id=?)
SEARCH order_history USING INDEX idx_history_order (order_id=?)
SEARCH o USING COVERING INDEX idx_orders_user (user_id=?)
SEARCH h USING INDEX idx_history_order (order_id=?)
USE TEMP B-TREE FOR ORDER BY
joy_orders = 60

Index-এর আগে দুটি lookup-ই SCAN: পুরো টেবিল। দুটি CREATE INDEX-এর পরে একই query SEARCH, অর্থাৎ index ধরে সোজা জায়গায়। অর্ডারের query-তে COVERING INDEX: দরকারি id (rowid) index-এর ভেতরেই আছে, টেবিলে যেতেই হয় না। শেষ plan-টি batched JOIN-এর: প্রথমে joy-র অর্ডার index দিয়ে, তারপর প্রতিটির ইতিহাস index দিয়ে, আর ক্রম সাজাতে একটি অস্থায়ী B-tree (USE TEMP B-TREE FOR ORDER BY); ৬০টি অর্ডারের ৩০০টি সারি সাজানো সস্তা। ব্রাউজারের plan ল্যাবের SQLite 3.50.4-এর plan-এর সাথে মেলে (একটি পার্থক্য: ল্যাবের অর্ডার-টেবিলে আরও কলাম আছে, তাই সেখানে SELECT o.*-এর query covering নয়)। একটি plan কতগুলো সারি পড়বে তা বলে না; সেটি দেখতে সময় মাপতে হয়, যা আগের অংশে করেছি।

N+1 — একটি তালিকা, তারপর প্রতিটির জন্য আলাদা query

N+1 query হলো এমন আকৃতি: একটি query দিয়ে N সারির তালিকা আনা, তারপর প্রতিটি সারির জন্য আরও query. বাজারঘরের কোড এমনই: orders() প্রথমে joy-র অর্ডারের id আনে, তারপর প্রতিটি id-র জন্য _order() ডাকে, যা ৩টি query চালায়। কোডটি পড়তে পরিষ্কার, আর কম data-য় নির্দোষ। ORM ব্যবহার করলে এটি আরও লুকিয়ে থাকে, কারণ order.history লিখলেই অদৃশ্যভাবে একটি query হয়; সেই দিকটি DBMS ও SQL কোর্সের পর্ব ৫৩-এ। একটি সমাধান হলো সব অর্ডারের item আর ইতিহাস JOIN দিয়ে একসাথে আনা, তারপর Python-এ অর্ডার ধরে ভাগ করা। কপিতে লেখা সংস্করণটি (LAB_ORDERS_BATCH=1 দিলে চলে), সংক্ষেপে:

def _orders_batched(self, user):            # 3 queries for the whole list
    with self.read() as conn:
        orders = conn.execute("SELECT o.* FROM orders o WHERE o.user_id = ? "
                              "ORDER BY o.id DESC", (user["id"],)).fetchall()
        items, history = {}, {}
        for i in conn.execute(ITEMS_JOIN_SQL, (user["id"],)):
            items.setdefault(i["order_id"], []).append(i)
        for h in conn.execute(HISTORY_JOIN_SQL, (user["id"],)):
            history.setdefault(h["order_id"], []).append(h)
    return [self._order_dict(o, items.get(o["id"], []), history.get(o["id"], []))
            for o in orders]

Index আর batching দুটি আলাদা সমাধান, আর দুটি আলাদা সমস্যা সারায়। কোনটি কতটা কাজ করে, অনুমান না করে মাপা হলো: একটি script একই data-র চারটি অবস্থায় load ছাড়া একটি request (Shop.orders(joy)) ৭ বার চালিয়ে median নিল, সত্যিকারের আউটপুট:

$ uv run python matrix.py lab.db
indexes=no   N+1      queries=181  median=  525.5 ms
indexes=no   batched  queries=  3  median=   30.5 ms
indexes=yes  N+1      queries=181  median=    4.2 ms
indexes=yes  batched  queries=  3  median=    3.3 ms
joy-র ৬০টি অর্ডার · ৪০ হাজার অর্ডারের database
কোড
index
query
history পড়া
median
  1. Query গোনা। তালিকার ১টি query, তারপর ৬০টি অর্ডারের প্রতিটির জন্য ৩টি: অর্ডার, item, ইতিহাস। মোট ১৮১টি। Joy-র অর্ডার ৬০০টি হলে ১৮০১টি: সংখ্যাটি data-র সাথে বাড়ে।
  2. দুই দোষ একসাথে। N+1 আর missing index: ইতিহাসের টেবিল ৬০ বার পুরো পড়া হয়, প্রতিবার দুই লাখ সারি। ফল ৫২৫.৫ ms. দুটি দোষ গুণ হয়ে যায়: query-র সংখ্যা × প্রতিটির খরচ।
  3. শুধু batching. Index ছাড়াই query ৩টি। ইতিহাসের টেবিল এখন একবার পড়া হয়: ৩০.৫ ms, প্রায় ১৭ গুণ দ্রুত। কিন্তু প্রতিটি request-এ এখনো পুরো টেবিল একবার পড়া, যা data বাড়লে আবার ধীর হবে।
  4. শুধু index. Query এখনো ১৮১টি, কিন্তু প্রতিটি index ধরে সরাসরি: ৪.২ ms, প্রায় ১২৫ গুণ দ্রুত। এখানে index-ই বড় সমাধান, কারণ খরচের মূল ছিল প্রতিটি query-র পুরো টেবিল পড়া।
  5. দুটিই। ৩টি query, প্রতিটি index ধরে: ৩.৩ ms. Index-এর ওপর batching-এর লাভ এখানে সামান্য (SQLite একই process-এ, তাই প্রতি query-র “যাতায়াত” সস্তা)। আলাদা database server-এ প্রতিটি query-র network-যাত্রা থাকে, সেখানে ১৮১ বনাম ৩-এর পার্থক্য অনেক বড় হতে পারত।

৬ · সারানো, তারপর আবার মাপা

সারানোর নিয়ম তিনটি, আর তিনটিই বৈজ্ঞানিক পরীক্ষার নিয়ম। এক: একবারে একটি পরিবর্তন, নইলে কোন পরিবর্তন কী করল তা জানা যায় না। দুই: প্রতিবার একই load, একই data, একই যন্ত্র, একই warm-up; শুধু পরিবর্তনটি আলাদা। তিন: প্রতিটি পরিবর্তনের পরে functional test-ও চালানো, কারণ দ্রুত কিন্তু ভুল উত্তর কোনো সমাধান নয়। নিচে বাজারঘরের চারটি ধাপ, প্রতিটি ১০ জন, ৩০ সেকেন্ড, একই script, সত্যিকারের আউটপুট (ছাঁটা):

[before] 10 users, 32 s
  requests=95 errors=0 throughput=2.9 req/s
  p50=3323 ms  p95=4700 ms  p99=4721 ms  max=4721 ms  mean=3274 ms
  Server-Timing: app;dur=571.3, db;desc="182 queries"
[+ index on order_history(order_id)] 10 users, 30 s
  requests=3837 errors=0 throughput=127.7 req/s
  p50=74 ms  p95=103 ms  p99=114 ms  max=163 ms  mean=78 ms
  Server-Timing: app;dur=11.7, db;desc="182 queries"
[+ index on orders(user_id)] 10 users, 30 s
  requests=4723 errors=0 throughput=157.2 req/s
  p50=62 ms  p95=83 ms  p99=97 ms  max=131 ms  mean=64 ms
[+ N+1 -> 3 queries] 10 users, 30 s
  requests=5499 errors=0 throughput=183.1 req/s
  p50=52 ms  p95=74 ms  p99=90 ms  max=128 ms  mean=55 ms
  Server-Timing: app;dur=6.0, db;desc="4 queries"

প্রথম index-টি (তৈরি হতে লেগেছে ৪৪ ms) একাই p95 ৪৭০০ থেকে ১০৩ ms-এ নামাল। Server চালু রেখেই index যোগ করা হয়েছিল, তাই কোড একটুও বদলায়নি, শুধু plan বদলেছে। দ্বিতীয় index আর batching আরও কিছু দিল, কিন্তু অনেক কম: সহজ বড় লাভ প্রথম ধাপেই শেষ। Batching-এর পরে কপির নিজের ১৫০টি pytest test (LAB_ORDERS_BATCH=1 uv run pytest) আবার চালানো হলো: 150 passed. অর্থাৎ উত্তর আগের মতোই সঠিক, শুধু দ্রুত।

শেষে NFR-2-এর আসল শর্তে, ৫০ জন ব্যবহারকারী, ৩০ সেকেন্ড, সব সারানোর পরে:

[after all fixes, NFR-2 users] 50 users, 30 s, orders/resp=60
  requests=5434 errors=0 throughput=179.4 req/s
  p50=273 ms  p95=321 ms  p99=362 ms  max=442 ms  mean=278 ms
  Server-Timing: app;dur=5.0, db;desc="4 queries"
  server process CPU: mean 124% of one core (max 138%)
  server process: peak memory 76 MB, file reads 6729.3 MB during the run

p95 ৩২১ ms, NFR-2-এর ২০০০ ms-এর অনেক নিচে, এই ল্যাপটপে, এই endpoint-এ। একটি জিনিস খেয়াল করুন: ব্যবহারকারী ১০ থেকে ৫০ হলো, কিন্তু throughput প্রায় একই (১৮৩ বনাম ১৭৯ req/s), আর p95 ৭৪ থেকে ৩২১ ms. System তার সর্বোচ্চ গতিতে পৌঁছে গেছে; বাড়তি ব্যবহারকারী শুধু সারি লম্বা করেন। পুরো সারানোর পরে একই ধরনের ৩০ সেকেন্ডের ১০ জনের run-এ ফাইল-পড়া ছিল প্রায় ৭৬৬৭ MB, ৬১৬২টি request-এ: প্রতি request-এ প্রায় ১.২ MB, আগের প্রায় ৫১৪ MB-এর জায়গায়। প্রতিটি নতুন connection-এ কিছু page আবার পড়া হয়, তাই শূন্য নয়; কিন্তু প্রায় ৪০০ গুণ কম।

সংখ্যাগুলো কি নিজেদের সাথে মেলে?

একজন ভালো tester load test-এর সংখ্যাকেও যাচাই করেন। দুটি সরল সূত্র কাজে আসে। Little's law (পর্ব ৪৬): system-এ গড়ে থাকা request = throughput × গড় সময়। Closed model-এ এটি ব্যবহারকারীর সংখ্যার প্রায় সমান হওয়ার কথা; অনেক কম হলে ব্যবহারকারীরা request-এর বাইরে সময় কাটাচ্ছেন, যেমন ব্যস্ত load generator-এ আটকে। আর utilization law: U = X × D, যেখানে D হলো একটি request-এর জন্য resource-এর মোট কাজ, যাকে service demand বলে। নিচের block আমাদের চারটি সত্যিকারের run-এর সংখ্যা নিয়ে হিসাব করে:

# Real runs from one laptop: 10 users, 30 s each, app limited to 2 threads
# (label, throughput X req/s, mean R ms, p95 ms, server CPU busy in cores U)
RUNS = [("before", 2.9, 3274, 4700, 1.95),
        ("+ history index", 127.7, 78, 103, 1.68),
        ("+ orders index", 157.2, 64, 83, 1.32),
        ("+ N+1 -> 3 queries", 183.1, 55, 74, 1.23)]
USERS, THREADS, NFR2_P95 = 10, 2, 2000

print(f"{'run':20} {'X*R':>5} {'CPU/req':>8} {'max X':>6} {'NFR-2':>6}")
for label, x, r_ms, p95, busy in RUNS:
    in_system = x * r_ms / 1000          # Little's law: N = X * R
    demand_ms = busy / x * 1000          # utilisation law: U = X * D
    x_max = THREADS / (demand_ms / 1000) # 2 threads, D seconds each
    verdict = "pass" if p95 <= NFR2_P95 else "FAIL"
    print(f"{label:20} {in_system:5.1f} {demand_ms:6.1f}ms {x_max:6.0f} {verdict:>6}")

base = RUNS[0]
for label, x, r_ms, p95, busy in RUNS[1:]:
    print(f"{label:20} p95 {base[3] / p95:5.1f}x lower, "
          f"throughput {x / base[1]:5.1f}x higher")

আসল আউটপুট (ব্রাউজারের Python):

run                    X*R  CPU/req  max X  NFR-2
before                 9.5  672.4ms      3   FAIL
+ history index       10.0   13.2ms    152   pass
+ orders index        10.1    8.4ms    238   pass
+ N+1 -> 3 queries    10.1    6.7ms    298   pass
+ history index      p95  45.6x lower, throughput  44.0x higher
+ orders index       p95  56.6x lower, throughput  54.2x higher
+ N+1 -> 3 queries   p95  63.5x lower, throughput  63.1x higher

X×R: চারটি run-এ ৯.৫ থেকে ১০.১, ব্যবহারকারীর সংখ্যা ১০-এর খুব কাছে। অর্থাৎ ব্যবহারকারীরা প্রায় পুরো সময় request-এর ভেতরেই ছিলেন, load generator নিজে আটকে যায়নি। প্রথম run-এর ৯.৫ একটু কম, কারণ শেষ মুহূর্তে চলমান ধীর request-গুলো মাপের বাইরে থেকে গেছে। CPU/req (service demand): আগে প্রতি request-এ প্রায় ৬৭২ ms CPU, প্রথম index-এর পরে ১৩.২ ms: কাজ ৫০ গুণ কমেছে, কেবল অপেক্ষা নয়। max X: দুটি thread আর এই service demand থেকে সর্বোচ্চ throughput-এর মডেল-সীমা। আগে মাত্র ৩ req/s, আর মাপা হয়েছিল ২.৯: system তার সীমায় দাঁড়িয়ে ছিল। পরে সীমা ১৫২–২৯৮ কিন্তু মাপা ১২৮–১৮৩, CPU-ও ২০০%-এর নিচে: এখন বাকি সময়ের একটি অংশ event loop আর একই ল্যাপটপের load generator-এর, তাই এই মডেল আর পুরো ছবি দেয় না। শেষ তিন সারি তুলনা: p95 আর throughput প্রায় সমান অনুপাতে বদলেছে, যা closed model-এ প্রত্যাশিত।

একই ল্যাপটপে মাপার সীমা। App আর load generator একই যন্ত্রে, তার ওপর অন্য কাজও চলছিল। তাই (১) দুই run-এর মধ্যে কয়েক শতাংশের পার্থক্য শব্দ হতে পারে: একই “before” অবস্থায় দুটি run-এ p95 ৪৭০০ আর ৪৪০৪ ms; (২) সারানোর পরে latency-র একটি অংশ load generator-এর নিজের; (৩) এই সংখ্যা production-এর ক্ষমতা নয়। কিন্তু ৪৭০০ থেকে ৭৪ ms-এর মতো ৬০ গুণ পার্থক্য শব্দের অনেক বাইরে, আর তার পেছনের কারণ (query plan) যন্ত্র-নিরপেক্ষ। ছোট উন্নতির (যেমন ৮৩ থেকে ৭৪ ms) দাবি করতে হলে কয়েকবার চালিয়ে পরিসর দেখাতে হয়।

Regression আটকানো — query-র সংখ্যার সীমা

Bottleneck সারানোর পরে প্রশ্ন: আগামী মাসে কেউ আবার N+1 ঢোকালে ধরবে কে? প্রতিটি pull request-এ load test চালানো ব্যয়বহুল আর শব্দপূর্ণ। সস্তা আর নির্ভরযোগ্য পাহারা হলো একটি functional test, যা query-র সংখ্যা গোনে, সময় নয়: query count budget. বাজারঘরের seed data-তেই joy-র তালিকায় N+1 কোড ৭টি query করে (১ + ২ × ৩), batched কোড ৩টি। Test-টি একটি সীমা বসায়, যেমন “অর্ডার যতই হোক, ৫টির বেশি নয়”, আর একজন ক্রেতার জন্য কয়েকটি বাড়তি অর্ডার বানিয়ে দেখে সংখ্যা বাড়ে কি না। সময় মাপার test flaky হয় (পর্ব ৪০), কিন্তু query-র সংখ্যা প্রতিবার একই: এটি deterministic. Django-র assertNumQueries-এর মতো ব্যবস্থা কিছু framework-এ তৈরি অবস্থায় থাকে; না থাকলে আমাদের Server-Timing-এর trace callback-এর মতো একটি counter-ই যথেষ্ট।

৭ · Bottleneck-এর মানচিত্র — lock, pool, serialization আর আরও

বাজারঘরের ঘটনাটি database-এর, কিন্তু ঘাট অনেক জায়গায় হতে পারে। প্রতিটির একটি লক্ষণ-ছাপ আছে, যা USE আর profile একসাথে দেখলে চেনা যায়:

ধরনলক্ষণপ্রমাণ কোথায়
App-এর CPUCPU পূর্ণ, latency load-এর সাথে বাড়েCPU profile-এ চওড়া Python function
Missing indexdata বাড়লে ধীর, কম data-য় দ্রুতEXPLAIN-এ SCAN, প্রচুর page পড়া
N+1 queryquery-র সংখ্যা সারির সংখ্যার সাথে বাড়েServer-Timing, query log, ncalls
Lock contentionCPU কম, তবু ধীর; লেখার সময় খারাপlock-এ অপেক্ষার stack, busy timeout
Connection বা thread pool পূর্ণCPU কম, latency ধাপে ধাপে বাড়েpool-এর অপেক্ষার সময়, ব্যস্ত thread-এর সংখ্যা
Serializationবড় উত্তরে ধীর, CPU পূর্ণprofile-এ JSON বা validation function
Loggingপ্রতি request-এ অনেক লেখা, disk ব্যস্তprofile-এ log handler, disk-এর লেখা
বাইরের callCPU প্রায় শূন্য, latency বাইরের service-এর সমানwall-clock profile, trace-এর span
GIL (Python)thread বাড়ালেও throughput বাড়ে নাএকটি core পূর্ণ, বাকিগুলো খালি

শেষ তিনটি সারির একটি সাধারণ ফাঁদ আছে। CPU profiler সাধারণত শুধু CPU-তে চলা সময় দেখায়; অপেক্ষার সময় (network, lock, disk) বাদ পড়তে পারে। py-spy ডিফল্টে অলস (idle) thread বাদ দেয়, --idle দিলে সেগুলোও দেখায়। cProfile-এর ডিফল্ট ঘড়ি দেয়াল-ঘড়ির সময় মাপে, তাই অপেক্ষাও তাতে আসে। তাই নিজেকে জিজ্ঞেস করুন: আমার profiler wall-clock time মাপছে, নাকি CPU time? CPU কম কিন্তু latency বেশি হলে উত্তর প্রায় সবসময় “কেউ কিছুর জন্য অপেক্ষা করছে”।

অনেক service মিলে তৈরি system-এ একটি request কয়েকটি service ঘুরে আসে; তখন প্রতিটি service-এর ভেতরে profile করার আগে দেখতে হয় কোন service-এ সময় গেল। এর যন্ত্র distributed tracing: প্রতিটি ধাপ একটি span, আর পুরো যাত্রা একটি ছবিতে। OpenTelemetry দিয়ে এর হাতে-কলমে চর্চা ক্লাউড ও DevOps কোর্সের পর্ব ৬৫-এ। আমাদের Server-Timing header এরই সবচেয়ে ছোট রূপ: একটি service নিজের ভেতরের সময়ের হিসাব দিচ্ছে।

আরও গভীরে: Profiler নিজেও ভুল বলতে পারে। Mytkowicz, Diwan, Hauswirth ও Sweeney-এর গবেষণা (“Evaluating the Accuracy of Java Profilers”, PLDI ২০১০) দেখিয়েছিল, একই প্রোগ্রামে বিভিন্ন Java profiler ভিন্ন ভিন্ন “hot” method দেখাতে পারে, কারণ অনেক sampler শুধু নির্দিষ্ট নিরাপদ বিন্দুতে নমুনা নেয়, যাকে safepoint bias বলে। আর deterministic profiler প্রতিটি call-এ খরচ যোগ করে ছোট function-কে বড় দেখায়; এটি observer effect-এর একটি রূপ। তাই একটি profile-কে প্রমাণ নয়, অনুমানের উৎস ভাবুন, আর অনুমানটি অন্য পথে যাচাই করুন: আমরা যেমন py-spy-এর লাইনকে EXPLAIN আর আলাদা সময়-মাপ দিয়ে মিলিয়েছি।

কখন থামবেন

সারানোর পরের profile (ছবি ৪৯.১, নিচে) দেখুন: তিনটি query মিলে ৪২%, বাকিটা event loop, token খোঁজা, validation. Amdahl's law (Gene Amdahl, ১৯৬৭) বলে, কাজের যে অংশ দ্রুত করছেন তার বাইরের অংশই গতিবৃদ্ধির সীমা টানে। Database-এর সব সময় শূন্য করে দিলেও লাভ সর্বোচ্চ ১ ÷ (১ − ০.৪২) ≈ ১.৭ গুণ। আর p95 এখন ৭৪ ms, লক্ষ্য ২০০০ ms. অর্থাৎ এখন থামার সময়; বাকি পরিশ্রম অন্য কোনো endpoint-এ বেশি কাজে আসবে। Performance-এর কাজের শেষ বিন্দু ঠিক করে requirement, profiler নয়।

পরীক্ষা ও ইন্টারভিউতে: এই ধরনের প্রশ্ন বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় প্রায়ই আসে।
প্র: USE আর RED-এর পার্থক্য? USE প্রতিটি resource-এর জন্য (utilization, saturation, errors); RED প্রতিটি service-এর জন্য (rate, errors, duration).
প্র: Deterministic বনাম sampling profiler? প্রথমটি প্রতিটি call গোনে, নিখুঁত সংখ্যা কিন্তু বেশি খরচ; দ্বিতীয়টি নিয়মিত stack-এর নমুনা নেয়, কম খরচ, চলমান process-এ লাগানো যায়।
প্র: N+1 কীভাবে ধরবেন? প্রতি request-এ query গুনে; সংখ্যা সারির সংখ্যার সাথে বাড়লে N+1. সমাধান JOIN বা IN দিয়ে একসাথে আনা, যাকে eager loading বলে।
প্র: EXPLAIN QUERY PLAN-এ SCAN মানে? পুরো টেবিল পড়া; বড় টেবিলে শর্তের কলামে index দরকার কি না দেখুন।
প্র: সারানোর পরে কী প্রমাণ দেবেন? একই load-এ আগের আর পরের p95 আর throughput, সাথে functional test পাস।

৮ · AI-এর যুগে — AI-এর “optimization” যাচাই

AI সহকারীকে “এই endpoint ধীর, দ্রুত করো” বললে উত্তর প্রায়ই আত্মবিশ্বাসী আর মাপহীন। সাধারণ ভুলগুলো: প্রতিটি কলামে index বসানোর পরামর্শ (লেখা ধীর হবে, অনেক index অকাজের); সমস্যা না বুঝেই cache যোগ (পুরোনো data দেখানোর নতুন bug); time.time() দিয়ে একবার মাপা “benchmark”; বানানো EXPLAIN আউটপুট বা অস্তিত্বহীন profiler option; আর চালানো ছাড়াই “এখন ১০ গুণ দ্রুত” দাবি। AI-এর লেখা performance test-ও প্রায়ই seed data-য় একজন ব্যবহারকারী দিয়ে চলে, যেখানে আমাদের ১৮১টি query-র সমস্যা ১ ms-এ লুকিয়ে থাকে।

AI-কে প্রমাণ দিন, আর সমাধানের শর্ত বলে দিন:

তুমি একজন অভিজ্ঞ performance engineer. বাজারঘরের GET /api/orders ধীর। প্রমাণ: ১০ জন ব্যবহারকারীতে p95 4700 ms; Server-Timing: 182 queries; cProfile-এ execute 915 বার (৫ বার ডাকায়); py-spy-এ ৯৭% নমুনা এই query-তে: SELECT status, at FROM order_history WHERE order_id = ? ORDER BY id EXPLAIN QUERY PLAN: SCAN order_history. Schema: [এখানে CREATE TABLE] নিয়ম: ১. প্রথমে মূল কারণ বলো, প্রমাণের কোন লাইন থেকে। ২. একবারে একটি পরিবর্তন প্রস্তাব করো, প্রত্যাশিত প্রভাবসহ; কোনো সংখ্যা দাবি করবে না। ৩. প্রতিটি index-এর জন্য লেখার খরচ আর কোন query তা ব্যবহার করবে বলো। ৪. Cache প্রস্তাব করলে invalidation কীভাবে হবে বলো। ৫. আমি কোন একই load আবার চালিয়ে, আর কোন functional test দিয়ে যাচাই করব, তা লিখে দাও।

AI-এর performance পরামর্শ হাতে পেলে — যাচাইয়ের চেকলিস্ট

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

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

প্র ০১USE আর RED দুটিই কেন লাগে? একটি দিয়ে কি কাজ চলে না?

দুটি পদ্ধতি দুটি ভিন্ন প্রশ্নের উত্তর দেয়। RED ব্যবহারকারীর দিক থেকে দেখে: প্রতিটি service বা endpoint কত request পাচ্ছে, কতগুলো ব্যর্থ, কত সময় লাগছে। “সমস্যা আছে কি না” আর “কোথায় অনুভূত হচ্ছে” জানার জন্য এটি সবচেয়ে সরাসরি। Tom Wilkie এটিকে microservice-এর dashboard সাজানোর একটি সরল নিয়ম হিসেবে প্রস্তাব করেছিলেন বলে পরিচিত, যাতে প্রতিটি service একই তিনটি প্রশ্নের উত্তর দেয়। কিন্তু RED বলে না সমস্যার উৎস কোন resource.

USE যন্ত্রের দিক থেকে দেখে: প্রতিটি resource কতটা ব্যস্ত, কোথায় সারি, কোথায় ভুল। Brendan Gregg-এর মূল যুক্তি ছিল পূর্ণতা: resource-এর তালিকা ধরে এগোলে কোনো জায়গা বাদ পড়ে না, আর “streetlight” অভ্যাস, অর্থাৎ শুধু পরিচিত জায়গায় খোঁজা, এড়ানো যায়। কিন্তু USE দিয়ে বোঝা যায় না কোন ব্যবহারকারীর কোন কাজে সমস্যা।

এই পর্বের ল্যাবে দুটি একসাথে কাজ করেছে। RED বলল: অর্ডারের endpoint-এ p95 ৪৪০৪ ms, ভুল শূন্য। ভুল শূন্য হওয়ায় timeout বা ব্যর্থ বাইরের call-এর সম্ভাবনা কমল। USE বলল: CPU দুটি thread-এই পূর্ণ, memory স্বাভাবিক, আর ফাইল-পড়ার পরিমাণ অবিশ্বাস্য। শুধু RED দেখলে “database ধীর” বলে থেমে যাওয়া সহজ ছিল; শুধু USE দেখলে কোন endpoint দায়ী তা অজানা থাকত, কারণ একই process অনেক endpoint চালায়।

Google-এর SRE বইয়ের (২০১৬) four golden signals-এ latency, traffic, errors আর saturation একসাথে আছে, অর্থাৎ RED-এর তিনটি আর USE-এর একটি। এটি দেখায়, বাস্তবে দলগুলো দুই দৃষ্টিকেই মেশায়। Tester-এর জন্য একটি ব্যবহারিক নিয়ম: load test-এর রিপোর্টে প্রতিটি endpoint-এর RED, আর পুরো run-এর জন্য প্রধান resource-গুলোর USE. দুটি ছাড়া রিপোর্ট অসম্পূর্ণ।

মূল উপলব্ধি: RED বলে কোথায় ব্যথা, USE বলে কোন অঙ্গ অসুস্থ। একটি দিয়ে রোগ চেনা যায়, দুটি দিয়ে চিকিৎসা শুরু করা যায়।

প্র ০২Functional test-এ সব সবুজ ছিল, তবু এত বড় performance bug কীভাবে লুকিয়ে থাকল? Test data-র আকার নিয়ে এর শিক্ষা কী?

বাজারঘরের ১৫০টি test প্রতিটি seed data-র নতুন কপিতে চলে, যেখানে joy-র ২টি অর্ডার আর পুরো দোকানে ৭টি। সেখানে অর্ডার তালিকা ৭টি query-তে প্রায় ১ ms-এ শেষ। Functional test-এর কাজ উত্তর সঠিক কি না দেখা, আর উত্তর সঠিক ছিল; তাই তারা ঠিক কাজই করেছে। সমস্যা ছিল আমাদের test strategy-তে: data-র আকার কোনো test-এর ইনপুট ছিল না।

N+1 আর missing index দুটিই আকার-নির্ভর bug. প্রথমটির খরচ সারির সংখ্যার সাথে রৈখিকভাবে বাড়ে, দ্বিতীয়টির খরচ টেবিলের আকারের সাথে; দুটি মিলে প্রায় গুণফলের মতো বাড়ে। ছোট data-য় দুটিই অদৃশ্য। ORM-এ এটি আরও স্বাভাবিক, কারণ for order in orders: order.history লেখাটি নিরীহ দেখায়। DBMS আর ORM-এর বইয়ে N+1 প্রায় সবসময় এই কারণেই সতর্কবার্তা হিসেবে থাকে।

এ থেকে কয়েকটি শিক্ষা। প্রথম, ISTQB-এর syllabus-এ volume testing-কে একটি আলাদা non-functional test-এর ধরন হিসেবে ধরা হয়, আর এই ঘটনা দেখায় কেন: বাস্তবসম্মত data-র আকার নিজেই একটি test condition. দ্বিতীয়, test data-র আকার requirement থেকে আসা উচিত, যেমন “এক বছরে আনুমানিক কত অর্ডার”, যদিও সেই সংখ্যা বাজারঘরের ক্ষেত্রে আমাদের অনুমান। তৃতীয়, আকার-নির্ভর bug ধরতে সবসময় বড় load লাগে না: query-র সংখ্যার সীমা দেওয়া একটি সাধারণ functional test দুটি অর্ডার থেকে দশটিতে গেলে query বাড়ছে কি না দেখেই N+1 ধরতে পারে, দ্রুত আর deterministic ভাবে।

Donald Knuth-এর বহুল উদ্ধৃত কথা (১৯৭৪ সালের একটি প্রবন্ধে) “premature optimization is the root of all evil”-কে অনেকে “performance নিয়ে পরে ভাবব”-এর অজুহাত বানান। কিন্তু একই অনুচ্ছেদে তিনি গুরুত্বপূর্ণ ছোট অংশটির কথাও বলেছিলেন, আর সেটি খুঁজতে মাপার যন্ত্রের ওপর জোর দিয়েছিলেন। Volume test সেই মাপারই অংশ।

মূল উপলব্ধি: Test data-র আকার একটি test design-এর সিদ্ধান্ত। ছোট data-য় সবুজ suite আকার-নির্ভর bug সম্পর্কে কিছুই বলে না।

প্র ০৩Index যোগ করা এত কার্যকর হলে প্রতিটি কলামে index বসিয়ে দিলে কী ক্ষতি?

Index বিনামূল্যে নয়। প্রতিটি index টেবিলের পাশে একটি আলাদা সাজানো কাঠামো। প্রতিটি INSERT, UPDATE বা DELETE-এ টেবিলের সাথে প্রতিটি সংশ্লিষ্ট index-ও বদলাতে হয়। বাজারঘরে একটি অর্ডার হলে ইতিহাসের টেবিলে একটি সারি যোগ হয়; নতুন idx_history_order-এর জন্য এখন আরেকটি B-tree-তেও লেখা লাগে। আমাদের ক্ষেত্রে এটি অবশ্যই লাভজনক, কারণ অর্ডার তালিকা পড়া হয় অনেক বেশি, লেখা হয় কম। কিন্তু যেখানে লেখা বেশি, যেমন click বা log জমানোর টেবিল, সেখানে প্রতিটি অতিরিক্ত index লেখার throughput কমায়।

দ্বিতীয় খরচ জায়গা আর memory. Index-এর page-ও cache-এ জায়গা নেয়; অনেক index মানে আসল data-র জন্য cache-এ কম জায়গা। তৃতীয়, planner-এর সিদ্ধান্ত জটিল হয়: একাধিক সম্ভাব্য index থাকলে ভুল বাছাইও সম্ভব, বিশেষত statistics পুরোনো হলে। চতুর্থ, অনেক index কোনো query-ই ব্যবহার করে না; শুধু “হয়তো লাগবে” ভেবে বসানো।

Tester-এর দৃষ্টিতে এর অর্থ: index যোগ করাও একটি পরিবর্তন, যার নিজের test দরকার। (১) EXPLAIN দিয়ে দেখা যে লক্ষ্য query সত্যিই নতুন index ব্যবহার করছে। (২) লেখার পথগুলোর ওপরও একটি load চালানো, যেমন অর্ডার দেওয়া, যাতে পড়া দ্রুত করতে গিয়ে লেখা ধীর না হয়। (৩) Migration-টি বড় টেবিলে কতক্ষণ নেয়, আর তখন টেবিল আটকে থাকে কি না দেখা। আমাদের ৪০ হাজার অর্ডারে index তৈরি ৪৪ ms, কিন্তু কোটি সারির টেবিলে মিনিট লাগতে পারে, আর কিছু database-এ তখন লেখা আটকে যায়।

একটি সূক্ষ্ম বিষয়ও আছে: ভালো index শুধু শর্তের কলাম নয়, কখনো ক্রম বা দরকারি কলামও ধরে রাখে। আমাদের idx_orders_user-এ SQLite plan-এ লিখেছে COVERING INDEX, কারণ query-র দরকারি id index-এর ভেতরেই আছে, টেবিলে যেতে হয়নি। এমন covering index পরিকল্পনা করে বানানো যায়, কিন্তু সেটিও মাপ দিয়ে যাচাই করতে হয়।

মূল উপলব্ধি: Index পড়াকে দ্রুত করে আর লেখাকে ধীর। কোন query-র জন্য index, তা জেনে বসান, আর পড়া ও লেখা দুই দিকই আবার মাপুন।

প্র ০৪Profiler কি কখনো ভুল জায়গা দেখাতে পারে? Profile-এর ফলকে কতটা বিশ্বাস করবেন?

পারে, আর সেটি বোঝা profiling-এর অর্ধেক দক্ষতা। প্রথম উৎস খরচ। Deterministic profiler প্রতিটি function call-এ ঢোকা-বেরোনো লেখে; যেখানে হাজার হাজার ছোট function, সেখানে মাপার খরচ আসল কাজের চেয়ে বড় হতে পারে, আর সেই function-গুলো profile-এ অকারণে বড় দেখায়। আমাদের cProfile run-এ এই সমস্যা কম ছিল, কারণ সময় যাচ্ছিল কয়েকটি বড় C call-এ।

দ্বিতীয় উৎস নমুনার পক্ষপাত। Sampling profiler নির্দিষ্ট বিরতিতে stack দেখে; বিরতির সাথে কোনো পর্যায়ক্রমিক কাজ মিলে গেলে, বা profiler শুধু নির্দিষ্ট নিরাপদ বিন্দুতে নমুনা নিতে পারলে, ফল বিকৃত হয়। Mytkowicz ও সহলেখকদের ২০১০ সালের PLDI গবেষণা Java profiler-এ এমন অমিল দেখিয়েছিল: একই প্রোগ্রামে আলাদা profiler আলাদা “hot” method. তৃতীয় উৎস attribution: Python-এ C extension-এর ভেতরের সময় যে Python লাইন C-কে ডেকেছে তার নামে যায়। আমাদের py-spy ফলে SQLite-এর কাজ “services.py:282”-এ দেখা গেছে; এটি সঠিক, কিন্তু না বুঝলে মনে হতে পারে Python লাইনটিই ধীর।

চতুর্থ উৎস ভুল প্রশ্ন। CPU profile অপেক্ষা দেখায় না; latency যদি network-এর অপেক্ষায় যায়, CPU profile সম্পূর্ণ ভিন্ন জায়গা দেখাবে। পঞ্চম উৎস ভুল পরিবেশ: ছোট data-য় profile করলে আমাদের সমস্যাটি দেখাই যেত না।

তাই profile-কে বিশ্বাস করার নিয়ম হলো ত্রিভুজ মেলানো: অন্তত দুটি স্বাধীন সূত্র একই কথা বলুক। এই পর্বে চারটি মিলেছে: Server-Timing-এর ৫৭১ ms আর cProfile-এর প্রতি ডাকে ৫৪৫ ms; cProfile-এর ১৮৩টি execute আর Server-Timing-এর ১৮২টি query (একটি token খোঁজা বাদ, দুটি PRAGMA যোগ); py-spy-এর লাইন আর EXPLAIN-এর SCAN; আর আলাদা মাপে ৬০ × ৮.৭ ms ≈ ৫২০ ms. চূড়ান্ত প্রমাণ সারানোর পরের মাপ: অনুমান সঠিক হলে ফল নাটকীয় হবে, আর হয়েছে।

মূল উপলব্ধি: Profile একটি সাক্ষী, বিচারক নয়। অন্য সাক্ষীর সাথে মিলিয়ে নিন, আর শেষ রায় দিক সারানোর পরের মাপ।

প্র ০৫দুই run-এর মধ্যে p95 ৮৩ থেকে ৭৪ ms হলো। এটি কি উন্নতি, নাকি শব্দ? কীভাবে নিশ্চিত হবেন?

এই পর্বের ল্যাবে একই “before” অবস্থায় দুটি run p95 দিয়েছিল ৪৭০০ আর ৪৪০৪ ms, প্রায় ৬% পার্থক্য, কোনো কোড না বদলে। এর কারণ পরিবেশ: একই ল্যাপটপে load generator আর app, অন্য কাজও চলছিল, operating system-এর scheduler আর cache-এর অবস্থা প্রতিবার আলাদা। তাহলে ৮৩ থেকে ৭৪ ms, প্রায় ১১% উন্নতি, একটি run-এর ভিত্তিতে নিশ্চিত দাবি করা কঠিন। অন্যদিকে ৪৭০০ থেকে ১০৩ ms, ৪৫ গুণ, কোনো শব্দ দিয়ে ব্যাখ্যা করা যায় না।

নিশ্চিত হওয়ার কয়েকটি ধাপ আছে। প্রথম, প্রতিটি অবস্থায় কয়েকবার চালানো, আর ক্রম মিশিয়ে (A, B, A, B), যাতে সময়ের সাথে বদলানো পরিবেশ একটি অবস্থাকেই প্রভাবিত না করে। দ্বিতীয়, একটি সংখ্যার বদলে পরিসর দেখা: যদি A-র সব run B-র সব run-এর চেয়ে খারাপ হয়, তবে পার্থক্যটি বিশ্বাসযোগ্য। তৃতীয়, p95 নিজেই একটি নমুনা থেকে অনুমান; ৫০০০ request-এ p95-এর অনিশ্চয়তা কম, কিন্তু ১০০ request-এ বেশ বড়। Bootstrap পদ্ধতিতে নমুনা থেকে বারবার নতুন নমুনা টেনে p95-এর একটি পরিসর বানানো যায়, পর্ব ৪০-এর confidence interval-এর মতো।

চতুর্থ ধাপটি সবচেয়ে শক্তিশালী: যান্ত্রিক কারণ খোঁজা। দ্বিতীয় index দেওয়ার পরে EXPLAIN-এ SCAN orders বদলে SEARCH … COVERING INDEX হয়েছে, আর আলাদা মাপে সেই query ৪.৫ ms থেকে প্রায় শূন্যে নেমেছে। Throughput ১২৭.৭ থেকে ১৫৭.২-তে উঠেছে, যা p95-এর পরিবর্তনের সাথে সামঞ্জস্যপূর্ণ। কারণ আর সংখ্যা মিললে ছোট উন্নতিতেও আস্থা রাখা যায়।

CI-তে performance regression ধরার সময় এই প্রশ্নটি প্রতিদিনের। সাধারণ উপায় হলো একটি সহনশীলতা রাখা (যেমন “baseline-এর চেয়ে ১০%-এর বেশি খারাপ হলে লাল”), আর সন্দেহ হলে আবার চালানো; এর পূর্ণ আলোচনা পর্ব ৫০-এর বিষয়। মূল ভুল হলো একটি run দেখে উল্লাস বা আতঙ্ক।

মূল উপলব্ধি: বড় পার্থক্য নিজেই কথা বলে; ছোট পার্থক্যের জন্য একাধিক run, পরিসর আর যান্ত্রিক কারণ লাগে। একটি সংখ্যা কখনো প্রমাণ নয়।

অনুশীলন

চারটিই কাগজ-কলমে করা যায়; চাইলে ব্রাউজারের Python block-এ নিজের হিসাব মিলিয়ে নিন।

  1. Spec থেকে performance test case: বাজারঘরের নতুন requirement: “একজন ক্রেতার ২০০টি পর্যন্ত অর্ডার থাকলেও অর্ডার তালিকার p95 ২০ জন একসাথে ব্যবহারে ৩০০ ms-এর বেশি হবে না; database-এ ১ লাখ অর্ডার ধরে নিন।” এই requirement যাচাইয়ের জন্য test case লিখুন: data, load, কী মাপবেন, পাসের শর্ত। সাথে একটি দ্রুত, deterministic test-ও প্রস্তাব করুন, যা প্রতিটি pull request-এ চলবে।
    IDDataLoadপাসের শর্ত
    P1100000 orders; test user 20020 users, 60 s, warm-up বাদp95 ≤ 300 ms, errors 0
    P2একই; test user 1 orderএকইp95 ≤ 300 ms (ছোট সীমাও)
    P3একই; user 201 orderএকইসীমার ঠিক বাইরে আচরণ লেখা
    F1seed + user-এর 2 আর 10 orderload নেইদুই অবস্থাতেই query ≤ 5

    P1 হলো requirement-এর সরাসরি রূপ; ২০০টি অর্ডারের ব্যবহারকারী হলো পর্ব ০৮-এর সীমার মান, আর P2–P3 সীমার দুই পাশ। প্রতিটি run-এ USE-এর মাপ (CPU, memory, ফাইল-পড়া) আর Server-Timing-এর query-সংখ্যা লিখে রাখুন, যাতে ফেল হলে কারণ খোঁজা সহজ হয়। পরিবেশ লিখুন (একই যন্ত্রে generator কি না)। F1 হলো query count budget: সংখ্যা অর্ডারের সাথে বাড়লে N+1, আর এটি সময় মাপে না বলে flaky নয়; তাই প্রতিটি pull request-এ চলতে পারে, P1–P3 nightly বা release-এর আগে।

  2. Profile পড়ে বলুন: চেকআউটের একটি endpoint ধীর। cProfile-এর নিচের অংশটি একটি উদাহরণ (চালানো হয়নি, শেখার জন্য বানানো)। Bottleneck কোথায়? কী নয়? পরের পদক্ষেপ কী?
    ncalls  tottime  cumtime  function
         1    0.002    2.950  checkout
         1    0.001    2.910  send_receipt_sms
         1    2.900    2.900  {method 'recv' of '_socket.socket' objects}
        50    0.030    0.030  rules.quote

    ২.৯৫ সেকেন্ডের প্রায় পুরোটা (cumtime ২.৯১০) send_receipt_sms-এর ভেতরে, আর তার মধ্যেও socket-এর recv-এ ২.৯ সেকেন্ড: অর্থাৎ program কিছু হিসাব করছে না, বাইরের একটি SMS service-এর উত্তরের অপেক্ষা করছে। cProfile-এর ডিফল্ট ঘড়ি দেয়াল-ঘড়ির সময় মাপে বলে অপেক্ষাটি ধরা পড়েছে। ব্যবসার নিয়মের হিসাব (rules.quote, ৫০ বার) মাত্র ০.০৩ সেকেন্ড, তাই কুপন বা delivery-র কোড দ্রুত করা অর্থহীন। এখানে CPU-র USE দেখলে CPU প্রায় খালি দেখাত। পরের পদক্ষেপ: SMS service-এর latency আলাদা মাপা; রসিদ পাঠানো checkout-এর পথ থেকে সরিয়ে পটভূমির কাজে (queue) দেওয়া; বাইরের call-এ timeout বসানো; আর test-এ SMS service-এর stub ব্যবহার (পর্ব ৩৪), যাতে আমাদের নিজের কোডের সময় আলাদা মাপা যায়।

  3. এই performance test-এর ভুল খুঁজুন:
    def test_orders_fast(client, login):
        token = login("joy")                  # fresh seed data
        t0 = time.time()
        r = client.get("/api/orders", headers=auth(token))
        elapsed = time.time() - t0
        print("orders took", elapsed)
        assert elapsed < 2                    # "NFR-2 says 2 seconds"

    অন্তত ছয়টি সমস্যা। (১) Data-র আকার: seed data-য় joy-র ২টি অর্ডার; আমাদের ল্যাবে ঠিক এই অবস্থায় request প্রায় ১ ms, তাই N+1 আর missing index থাকলেও test সবুজ। (২) একটি নমুনা: একবার মেপে p95 বলা যায় না; NFR-2 percentile-এর কথা বলে। (৩) Concurrency নেই: NFR-2-এর শর্ত ৫০ জন একসাথে; একজনের সময় সারি তৈরি হওয়া দেখায় না। (৪) ভুল ঘড়ি: time.time() দেয়াল-ঘড়ি, যা সমন্বয়ে লাফাতে পারে; সময়ের ব্যবধান মাপতে time.perf_counter(). (৫) Status যাচাই নেই: ৫০০ ভুলও দ্রুত হতে পারে, আর test তবু পাস; আগে r.status_code == 200. (৬) Warm-up আর পরিবেশ অজানা: প্রথম request-এ বাড়তি খরচ, আর in-process client network বাদ দেয়। print কোনো যাচাই নয়। ভালো বিকল্প দুটি: একটি query count budget test (deterministic, প্রতিটি pull request-এ), আর বড় data-য় আলাদা load test, percentile আর USE-সহ।

  4. N+1-এর হিসাব: একজন ক্রেতার ২০০টি অর্ডার। Index ছাড়া ইতিহাসের query প্রতিবার ৮.৭ ms, অর্ডার আর item-এর query প্রতিটি ০.০০৮ ms, আর অর্ডারের তালিকার query একবার ৪.৫ ms. (ক) একটি request-এ মোট query কতটি, আর সময় আনুমানিক কত? (খ) Server-এ ২টি worker thread থাকলে সর্বোচ্চ throughput কত? (গ) ২০ জন ব্যবহারকারী বিরতি ছাড়া request পাঠালে Little's law অনুযায়ী গড় সময় কত হবে?

    (ক) ১ + ২০০ × ৩ = ৬০১টি query. সময় ≈ ৪.৫ + ২০০ × ৮.৭ + ২০০ × ২ × ০.০০৮ = ৪.৫ + ১৭৪০ + ৩.২ ≈ ১৭৪৭.৭ ms, প্রায় ১.৭৫ সেকেন্ড, একজন ব্যবহারকারীতেই। (খ) প্রতিটি thread সেকেন্ডে ১ ÷ ১.৭৪৭৭ ≈ ০.৫৭টি request; দুটি thread মিলে প্রায় ১.১৪ req/s. (গ) Closed model-এ system-এ সবসময় ২০টি request: R = N ÷ X = ২০ ÷ ১.১৪ ≈ ১৭.৫ সেকেন্ড। অর্থাৎ ব্যবহারকারী প্রতি request-এ গড়ে প্রায় সাড়ে ১৭ সেকেন্ড অপেক্ষা করবেন, যদিও একটি request-এর নিজের কাজ পৌনে দুই সেকেন্ড। বাকিটা সারি। Index দিলে ইতিহাসের query প্রায় ০.০০৮ ms-এর ঘরে নামবে, আর সারিটিও প্রায় মিলিয়ে যাবে; ব্রাউজারের Python block-এ সংখ্যা বদলে নিজে দেখে নিন।

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

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

ক্রমএকটি ধীর endpoint-এর bottleneck খোঁজা আর সারানোর ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. বাস্তবসম্মত data আর load-এ লক্ষণ মাপা: p95, throughput, errors (baseline)
  2. USE আর RED দিয়ে দেখা কোন resource ভরা বা কোথায় অপেক্ষা
  3. Profiler দিয়ে hot spot খোঁজা আর একটি পরীক্ষাযোগ্য অনুমান লেখা
  4. Query plan বা কোড পড়ে অনুমানটি নিশ্চিত করা
  5. একটি পরিবর্তন করে functional test চালানো
  6. একই load আবার চালিয়ে baseline-এর সাথে তুলনা করা

Brendan Gregg-এর USE method প্রতিটি resource-এর জন্য কোন তিনটি জিনিস দেখতে বলে?

  • Rate, errors, duration
  • Utilization, saturation, errors
  • Users, sessions, events
  • Uptime, speed, efficiency

একটি endpoint ৫ বার ডেকে cProfile-এ দেখা গেল sqlite3-এর execute ৯১৫ বার ডাকা হয়েছে, আর ব্যবহারকারীর ৬০টি অর্ডার আছে। এটি সবচেয়ে বেশি কিসের ইঙ্গিত দেয়?

  • শুধু missing index
  • Python কোড ধীর
  • N+1 query: প্রতিটি অর্ডারের জন্য আলাদা query
  • Network-এর ধীরতা

SQLite-এর EXPLAIN QUERY PLAN-এ SCAN order_history দেখা গেল, query-টি WHERE order_id = ?. এর সবচেয়ে সম্ভাব্য অর্থ কী?

  • order_id কলামে কোনো ব্যবহারযোগ্য index নেই, তাই পুরো টেবিল পড়া হচ্ছে
  • Query কোনো সারি ফেরত দেবে না
  • টেবিলটি lock হয়ে আছে
  • Index ঠিকমতো ব্যবহার হচ্ছে

চলমান একটি production-এর মতো server-এ কোড না বদলে, কম খরচে, load চলার সময়ই কোন source লাইনে সময় যাচ্ছে তা দেখতে কোনটি সবচেয়ে উপযুক্ত?

  • Server-কে cProfile-এর নিচে আবার চালু করা
  • কোডে print দিয়ে সময় লেখা
  • প্রতিটি query-র EXPLAIN QUERY PLAN
  • py-spy-এর মতো sampling profiler দিয়ে process-এ নমুনা নেওয়া

একটি সারানোর পরে profile-এ দেখা গেল database-এর অংশ মোট সময়ের ৪২%. Database-এর সময় পুরো শূন্য করে দিলেও সর্বোচ্চ কত গুণ দ্রুত হবে?

  • প্রায় ১০০ গুণ
  • প্রায় ১.৭ গুণ
  • প্রায় ২.৪ গুণ
  • একটুও না

একজন developer একসাথে তিনটি পরিবর্তন করলেন (দুটি index, query বদল আর একটি cache), তারপর একটি load test চালিয়ে বললেন “p95 ৮০% কমেছে”। Tester হিসেবে প্রধান আপত্তি কী?

  • p95-এর বদলে গড় সময় দেখা উচিত ছিল
  • Index কখনো যোগ করা উচিত নয়
  • কোন পরিবর্তন কী প্রভাব ফেলল জানা যায় না, আর একটি run-এ শব্দ আলাদা করা যায় না
  • Functional test চালানোর দরকার নেই

একটি endpoint-এর latency অনেক বেশি, কিন্তু load-এর সময় app process-এর CPU প্রায় ৫%. সবচেয়ে সম্ভাব্য ব্যাখ্যা কোনটি?

  • Request কিছুর জন্য অপেক্ষা করছে: বাইরের call, lock বা পূর্ণ pool
  • Python-এর হিসাবের কোড খুব ভারী
  • System ঠিক আছে, latency মাপায় ভুল
  • Database-এ missing index

শব্দকোষ

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

মনে রাখুন

  1. একটি ঘাট: সাধারণত একটি জায়গাই গতির সীমা টানে; অন্য জায়গা দ্রুত করলে লাভ নেই, আর একটি সারালে পরেরটি সামনে আসে।
  2. চেকলিস্ট, অনুমান নয়: resource-এর জন্য USE, service-এর জন্য RED; CPU কম অথচ ধীর মানে অপেক্ষা।
  3. Profile একটি সাক্ষী: cProfile গোনে (ncalls), py-spy লাইন দেখায়; Server-Timing আর EXPLAIN দিয়ে মিলিয়ে নিন।
  4. আকার-নির্ভর bug: N+1 আর missing index ছোট data-য় অদৃশ্য; volume test আর query count budget দিয়ে ধরুন।
  5. সারানো, তারপর আবার মাপা: একবারে একটি পরিবর্তন, একই load, functional test পাস; requirement পূরণ হলে থামুন।

পরের পর্বে: “দ্রুত যথেষ্ট” কে ঠিক করে? SLI, SLO আর error budget দিয়ে performance-এর লক্ষ্যকে CI-র gate বানানো, ১ বনাম ২টি worker-এ বাজারঘর মাপা, ভেঙে পড়ার বিন্দু পর্যন্ত চাপ, আর ঈদের মতো ভিড়ের দিনের জন্য capacity-র পরিকল্পনা।

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

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