29.10-dars: Benchmark va yuk testi

29-QISM — MIQYOS VA UNUMDORLIK · 10-dars

1. Kirish va motivatsiya

Tizimni optimallashtirdik (kesh, async, miqyoslash) — lekin ishlaydimi? Haqiqiy yukni ko'taradimi? 1000 foydalanuvchi bir vaqtda kelsa — nima bo'ladi? Qachon yiqiladi? Buni ishlab chiqarishda bilish — kech (foydalanuvchi zarar ko'radi). Dasturchilar ko'pincha "yetarli tez bo'lsa kerak" deb taxmin qiladi va prodda yiqiladi (Black Friday, viral post — kutilmagan yuk). Benchmark va yuk testi buni oldindan aniqlaydi: nazorat sinovlari (benchmark) unumdorlikni o'lchaydi, yuk testi (ko'p foydalanuvchi simulyatsiyasi) tizim chegaralarini topadi. Test — muammoni prodda emas, oldindan topish.

Benchmark va yuk testi — tizim unumdorligini sinash: benchmark (nazorat sinovi — bir amal/funksiya tezligini o'lchash, taqqoslash — 29.1), yuk testi (load testing — ko'p bir vaqtda foydalanuvchi simulyatsiyasi — normal yuk), stress testi (chegaradan oshirish — qachon yiqiladi), spike testi (birdan yuk — kutilmagan), soak testi (uzoq — leak, degradatsiya). Vositalar: Locust (Python — yuk testi), k6, Apache JMeter, wrk, ab. O'lchovlar: latency (p95, p99 — 28.10), throughput, xatolik foizi, resurs. Prinsip: oldindan test → chegara → optimallashtir. Bu monitoring 28.10-bob, unumdorlik 29.1-bob bilan bog'liq. Benchmark/yuk testi — chegarani oldindan topish. Test — kutilmagan yukga tayyorlik.

Real vaziyat. Bir tizim yaxshi ishlayapti deb o'ylanardi (kam foydalanuvchi bilan). Katta e'lon oldidan yuk testi o'tkazildi (Locust — 5000 virtual foydalanuvchi): ma'lum bo'ldi, tizim 2000 foydalanuvchida yiqilardi (baza ulanishlari tugardi — 29.7). Baza ulanish havzasi kattalashtirildi, kesh qo'shildi 29.3-bob. Qayta test: 10,000 foydalanuvchini ko'tardi. E'lon kuni tizim ishladi (test bilan tayyorlangan). Yuk testi — falokatni oldini oldi.

Bu darsda benchmark va yuk testini o'rganamiz.

Bu darsda:

• Nega test (oldindan)
• Benchmark (nazorat sinovi)
• Yuk testi turlari (load, stress, spike, soak)
• Yuk testi o'lchovlari
• Chegarani topish (bottleneck)
• Test amaliyoti
• Benchmark tuzoqlari
• Amaliy: yuk testi modeli

ℹ Yuk testi alohida vosita; misollar Python bilan test mantiqini modellashtiradi (deterministik).

2. Nazariya — chuqur tushuntirish

2.1. Nega test (oldindan)

Muammoni prodda emas, oldindan:

Testsiz: yuk prodda keladi → yiqiladi (kech, zarar)
   "yetarli tez bo'lsa kerak" (taxmin) → falokat

Test: yukni oldindan simulyatsiya → chegara aniqlanadi
   muammo test'da (oldindan) → tuzatiladi

Nega test — tizim haqiqiy yukni ko'taradimi — oldindan bilish kerak (prodda emas — kech, foydalanuvchi zarar): benchmark/yuk testi yukni simulyatsiya qiladi (haqiqiy foydalanuvchilarsiz), chegarani topadi. Sabab: dasturchi "yetarli tez bo'lsa kerak" (taxmin — 29.1, ko'pincha noto'g'ri), prodda yiqiladi (kutilmagan yuk — viral, Black Friday); test muammoni oldindan ko'rsatadi (arzon — 28.7 CI kabi, tez topilgan xato arzon). Test — ishonch (yukni ko'taradi) va tayyorlik (kutilmagan yukga). Test — oldindan aniqlash. Oldindan — arzon.

2.2. Benchmark (nazorat sinovi)

Bir amal tezligini o'lchash:

# benchmark — bir funksiya/amal tezligi (29.1)
import timeit
vaqt = timeit.timeit(lambda: funksiya(), number=1000)
# o'rtacha vaqt (ko'p marta — barqaror)

# taqqoslash: eski vs yangi (optimallashtirish tasdiqlash)

Benchmark (nazorat sinovi) — bir amal/funksiya tezligini o'lchash va taqqoslash (29.1 — mikro daraja): timeit (ko'p marta — barqaror), turli yechimlarni solishtirish (eski vs yangi — optimallashtirish tasdiqlash), regressiya (yangi kod sekinlashtirdimi?). Sabab: optimallashtirishni o'lchash (yaxshilandimi? — 29.1), yechimlarni taqqoslash (qaysi tez?). Farqi yuk testidan: benchmark bir amal (mikro), yuk testi butun tizim (ko'p foydalanuvchi — makro). Benchmark — kod darajasidagi o'lchov. Yuk testi — tizim darajasidagi. Benchmark — bir amal (tez o'lchov).

2.3. Yuk testi turlari (load, stress, spike, soak)

Yuk testi turlari: Load testi (yuk — normal/kutilgan yukni simulyatsiya: tizim odatiy yukda ishlaydimi? — latency, throughput); Stress testi (chegaradan oshirish — yukni ko'paytiraverish: qachon yiqiladi? chegara qayerda?); Spike testi (birdan yuk — kutilmagan sakrash: viral post, e'lon — tizim moslashadimi?); Soak testi (uzoq — uzoq davomli yuk: xotira leak — 29.9, degradatsiya — asta sekinlashish). Sabab: turli xavflar (normal yuk, chegara, sakrash, uzoq muddat) turli test. Har tur bir savol (ishlaydimi, chegara, sakrash, uzoq). Turlar — turli yuk stsenariylari. Har biri — bir xavf.

2.4. Yuk testi o'lchovlari

Yuk testi o'lchovlari (28.10 metrikalar): latency (javob vaqti — p95, p99 persentil, 28.10 — o'rtacha aldamchi), throughput (soniyada so'rov — sig'im, 29.1), xatolik foizi (yukda qancha xato — 28.10 RED), resurs (CPU, xotira, ulanish — nima tugaydi), concurrent users (bir vaqtdagi foydalanuvchi — qanchagacha). Yuk oshganda o'lchovlar qanday o'zgaradi (yuk ↑ → latency ↑? xatolik ↑?) — chegarani ko'rsatadi (latency portlagan nuqta). Sabab: test ma'lumot beradi (raqamlar — 29.1) — qaror uchun (chegara, optimallashtirish). O'lchovlar — test natijasi. Persentil, throughput, xatolik.

2.5. Chegarani topish (bottleneck)

Qachon va nima uchun yiqiladi:

Yuk oshiriladi → o'lchovlar kuzatiladi:
   yuk kam: latency past, xatolik 0 (yaxshi)
   yuk oshadi: latency oshadi (sekinlashish)
   chegara: latency portlaydi, xatolik oshadi (yiqilish)

bottleneck: nima chegara? (CPU? baza? ulanish? — profiling 29.2)

Chegarani topish — yukni oshiraverib tizim qachon va nima uchun yiqilishini aniqlash: yuk oshganda o'lchovlar kuzatiladi — chegarada latency portlaydi (birdan oshadi), xatolik oshadi (yiqilish). Bottleneck (29.2 — to'siq): nima chegara? (CPU tugadi? baza ulanishlari — 29.7? xotira — 29.9? tashqi API?) — profiling 29.2-bob, monitoring 28.10-bob bilan aniqlanadi. Sabab: chegarani bilish — miqyoslash rejasi (qachon server qo'shish — 29.6, nimani optimallashtirish). Bir bottleneck tuzatilsa — keyingisi (iterativ — 29.2). Chegara — tizim sig'imi. Bottleneck — nima cheklaydi.

2.6. Test amaliyoti

Test amaliyotlari: real sharoit (prodga o'xshash muhit — 28.13, real ma'lumot hajmi — 29.1); bosqichma yuk (asta oshirish — chegarani ko'rish); persentil (p95, p99 — o'rtacha emas, 28.10); realistik stsenariy (haqiqiy foydalanuvchi xatti-harakati — nafaqat bir endpoint); monitoring bilan (28.10 — test paytida resurs, bottleneck); CI'da (28.7 — regressiya, unumdorlik pasaydimi?); prodga yaqin, lekin prodda emas (staging — 28.8). Tuzoqlar: noreal sharoit (kichik ma'lumot, kesh isigan), faqat bir endpoint, o'rtacha (persentil emas), prodda test (foydalanuvchi zarar). Yaxshi test — realistik, bosqichma, monitoring bilan. Amaliyot — ishonchli test. Realistik — foydali natija.

2.7. Benchmark tuzoqlari

Benchmark tuzoqlari (o'lchov noto'g'ri bo'lsa — noto'g'ri xulosa): isigan kesh (birinchi sekin, keyingi tez — 29.3; qaysini o'lchash?), kichik ma'lumot (prod — katta, 29.1), JIT/optimizatsiya (takroriy — tizim optimallashtiradi), shovqin (bir marta — o'zgaruvchan, ko'p marta o'rtacha — 29.1), noreal stsenariy (sun'iy — real emas), o'lchov ta'siri (o'lchash o'zi sekinlashtiradi — 29.2 observer effect), taqsimlangan effektlar (bir mashinada test — prod ko'p server). Sabab: benchmark o'lchov 29.1-bob — noto'g'ri o'lchov noto'g'ri qaror (mikro-optimizatsiya — 28.4). Yaxshi benchmark: ko'p marta, real sharoit, realistik. Tuzoq — noreal o'lchov. Benchmark ham to'g'ri qilinishi kerak.

2.8. Test — kutilmagan yukga tayyorlik

Benchmark/yuk testi asosiy g'oyasi — kutilmagan yukga tayyorlik (prodda emas, oldindan): tizim chegarasi bilinsa — reja (qachon miqyoslash — 29.6, nimani optimallashtirish), ishonch (yukni ko'taradi), tayyorlik (Black Friday, viral). Bu unumdorlik (29.1 — o'lchash), profiling (29.2 — bottleneck), monitoring (28.10 — prodda), miqyoslash (29.6 — server) bilan to'liq unumdorlik nazorati. "O'lcha, profiling, test, optimallashtir, monitoring" (unumdorlik sikli). Test CI/CD (28.7-8 — unumdorlik regressiya) bilan uyg'un. "Yiqilishni oldindan ko'r" (test) — muhandislik prinsipi. Benchmark/yuk testi — chegarani oldindan bilish. Test — ishonch va tayyorlik.

3. Tez ma'lumotnoma

# BENCHMARK (bir amal — 29.1):
import timeit
vaqt = timeit.timeit(lambda: funksiya(), number=1000)   # o'rtacha
# taqqoslash: eski vs yangi (optimallashtirish tasdiqlash)

# YUK TESTI TURLARI:
# load (normal yuk) · stress (chegaradan oshirish)
# spike (birdan yuk) · soak (uzoq — leak)

# VOSITALAR: Locust (Python), k6, JMeter, wrk, ab

# Locust misoli:
# class User(HttpUser):
#     @task
#     def sahifa(self): self.client.get("/api/mahsulotlar")

# O'LCHOVLAR:
# latency (p95, p99 — 28.10) · throughput (soniyada so'rov)
# xatolik foizi · resurs (CPU, xotira) · concurrent users

# CHEGARA: yuk ↑ → latency portlaydi (bottleneck — 29.2)
# PRINSIP: oldindan test → chegara → optimallashtir

Benchmark va yuk testi xulosasi

Test — yukni oldindan simulyatsiya (prodda emas, chegara)
Benchmark (bir amal — timeit) · yuk testi (butun tizim — Locust)
Turlar: load (normal), stress (chegara), spike, soak (leak)
O'lchovlar: latency (p95/p99), throughput, xatolik, resurs
Chegarani topish (bottleneck — 29.2) · kutilmagan yukga tayyorlik

4. Batafsil misollar

Yuk testi alohida vosita; misollar Python bilan test mantiqini modellashtiradi.

Misol 1 — Benchmark (yechimlarni taqqoslash)

"""Benchmark: ikki yechimni amal soni bilan taqqoslash (qaysi samarali)."""


def yechim_list(data: list, qidiruvlar: list) -> int:
    # O(n*m) — list qidiruv
    amallar = 0
    for q in qidiruvlar:
        for x in data:
            amallar += 1
            if x == q:
                break
    return amallar


def yechim_set(data: list, qidiruvlar: list) -> int:
    # O(n+m) — set qidiruv
    amallar = len(data)   # set qurish
    tuplam = set(data)
    for q in qidiruvlar:
        amallar += 1       # O(1) qidiruv
        _ = q in tuplam
    return amallar


def main() -> None:
    data = list(range(100))
    qidiruvlar = [50, 99, 25, 75]

    print("=== 1. Yechim A (list qidiruv) ===")
    a = yechim_list(data, qidiruvlar)
    print(f"  amallar: {a}")

    print("\n=== 2. Yechim B (set qidiruv) ===")
    b = yechim_set(data, qidiruvlar)
    print(f"  amallar: {b}")

    print("\n=== 3. Taqqoslash (benchmark) ===")
    print(f"  list: {a}, set: {b}")
    print(f"  set ~{a // b}x samarali (kam amal)")

    print("\n=== 4. Benchmark maqsadi ===")
    print("  yechimlarni taqqoslash (qaysi tez)")
    print("  optimallashtirish tasdiqlash (yaxshilandimi?)")
    print("  ⭐ Benchmark — yechimlarni o'lchab taqqoslash")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Yechim A (list qidiruv) ===
  amallar: 253

=== 2. Yechim B (set qidiruv) ===
  amallar: 104

=== 3. Taqqoslash (benchmark) ===
  list: 253, set: 104
  set ~2x samarali (kam amal)

=== 4. Benchmark maqsadi ===
  yechimlarni taqqoslash (qaysi tez)
  optimallashtirish tasdiqlash (yaxshilandimi?)
  ⭐ Benchmark — yechimlarni o'lchab taqqoslash

Nima ko'rsatdi: 2.2-bo'lim.

Misol 2 — Yuk testi (yuk oshganda o'lchovlar)

"""Yuk testi: yuk oshganda latency va xatolik (chegarani ko'rish)."""


def tizim_javobi(concurrent_users: int, sigim: int = 1000) -> dict:
    # yuk sig'imgacha — normal, keyin sekinlashadi/yiqiladi
    if concurrent_users <= sigim:
        latency = 100 + (concurrent_users / sigim) * 100   # 100-200ms
        xatolik = 0.0
    else:
        # chegaradan oshdi — latency portlaydi, xatolik oshadi
        oshiq = concurrent_users - sigim
        latency = 200 + oshiq / 10   # keskin oshadi
        xatolik = min(oshiq / sigim * 100, 100)
    return {"latency_ms": round(latency), "xatolik_foiz": round(xatolik, 1)}


def main() -> None:
    print("=== 1. Yuk bosqichma oshiriladi ===")
    for users in [500, 1000, 1500, 2000]:
        j = tizim_javobi(users)
        print(f"  {users} user: latency {j['latency_ms']}ms, xatolik {j['xatolik_foiz']}%")

    print("\n=== 2. Normal yuk (sig'imgacha) ===")
    j = tizim_javobi(800)
    print(f"  800 user: {j['latency_ms']}ms (yaxshi)")

    print("\n=== 3. Chegaradan oshiq ===")
    j = tizim_javobi(1500)
    print(f"  1500 user: {j['latency_ms']}ms, {j['xatolik_foiz']}% (yiqilish)")

    print("\n=== 4. Chegara ===")
    print("  ~1000 user gacha normal, keyin latency portlaydi")
    print("  bu chegara → miqyoslash rejasi 29.6-bob")
    print("  ⭐ Yuk testi — chegarani ko'rsatadi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Yuk bosqichma oshiriladi ===
  500 user: latency 150ms, xatolik 0.0%
  1000 user: latency 200ms, xatolik 0.0%
  1500 user: latency 250ms, xatolik 50.0%
  2000 user: latency 300ms, xatolik 100.0%

=== 2. Normal yuk (sig'imgacha) ===
  800 user: 180ms (yaxshi)

=== 3. Chegaradan oshiq ===
  1500 user: 250ms, 50.0% (yiqilish)

=== 4. Chegara ===
  ~1000 user gacha normal, keyin latency portlaydi
  bu chegara → miqyoslash rejasi 29.6-bob
  ⭐ Yuk testi — chegarani ko'rsatadi

Nima ko'rsatdi: 2.3, 2.5-bo'limlar.

Misol 3 — Test turlari (load, stress, spike, soak)

"""Test turlari: har biri boshqa yuk stsenariysi (boshqa xavf)."""


TEST_TURLARI = {
    "load": {"maqsad": "normal yuk ishlaydimi", "yuk": "kutilgan"},
    "stress": {"maqsad": "qachon yiqiladi", "yuk": "chegaradan oshiq"},
    "spike": {"maqsad": "birdan sakrash", "yuk": "kutilmagan"},
    "soak": {"maqsad": "uzoq — leak/degradatsiya", "yuk": "uzoq davomli"},
}


def main() -> None:
    print("=== 1. Test turlari ===")
    for nom, info in TEST_TURLARI.items():
        print(f"  {nom}: {info['maqsad']}")

    print("\n=== 2. Load testi (normal) ===")
    print(f"  yuk: {TEST_TURLARI['load']['yuk']}")
    print("  tizim odatiy yukda ishlaydimi (latency)")

    print("\n=== 3. Stress testi (chegara) ===")
    print(f"  yuk: {TEST_TURLARI['stress']['yuk']}")
    print("  yukni oshiraverib — qachon yiqiladi")

    print("\n=== 4. Har tur — bir xavf ===")
    print("  load: normal · stress: chegara")
    print("  spike: sakrash · soak: uzoq (leak — 29.9)")
    print("  ⭐ Test turlari — turli yuk stsenariylari")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Test turlari ===
  load: normal yuk ishlaydimi
  stress: qachon yiqiladi
  spike: birdan sakrash
  soak: uzoq — leak/degradatsiya

=== 2. Load testi (normal) ===
  yuk: kutilgan
  tizim odatiy yukda ishlaydimi (latency)

=== 3. Stress testi (chegara) ===
  yuk: chegaradan oshiq
  yukni oshiraverib — qachon yiqiladi

=== 4. Har tur — bir xavf ===
  load: normal · stress: chegara
  spike: sakrash · soak: uzoq (leak — 29.9)
  ⭐ Test turlari — turli yuk stsenariylari

Nima ko'rsatdi: 2.3-bo'lim.

Misol 4 — Chegarani topish (bottleneck)

"""Chegara: yuk oshganda qaysi resurs birinchi tugaydi (bottleneck)."""


def resurs_holati(concurrent_users: int) -> dict:
    # har resursning yukka nisbatan holati (foiz)
    return {
        "cpu": min(concurrent_users / 3000 * 100, 100),
        "xotira": min(concurrent_users / 5000 * 100, 100),
        "baza_ulanish": min(concurrent_users / 1000 * 100, 100),   # eng past chegara
    }


def bottleneck_top(holat: dict) -> str:
    # eng yuqori foizli resurs — bottleneck
    return max(holat, key=lambda r: holat[r])


def main() -> None:
    print("=== 1. Yuk 800 user ===")
    h = resurs_holati(800)
    for resurs, foiz in h.items():
        print(f"  {resurs}: {round(foiz)}%")

    print("\n=== 2. Bottleneck (eng band) ===")
    bn = bottleneck_top(h)
    print(f"  {bn}: {round(h[bn])}% — birinchi to'ladi")

    print("\n=== 3. Yuk oshadi (1000 user) ===")
    h2 = resurs_holati(1000)
    bn2 = bottleneck_top(h2)
    print(f"  {bn2}: {round(h2[bn2])}% (chegaraga yetdi)")

    print("\n=== 4. Chegarani ochish ===")
    print(f"  baza_ulanish — bottleneck (birinchi tugaydi)")
    print("  yechim: ulanish havzasini kattalashtirish 29.7-bob")
    print("  bir bottleneck tuzatilsa — keyingisi (iterativ 29.2)")
    print("  ⭐ Bottleneck — nima birinchi cheklaydi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Yuk 800 user ===
  cpu: 27%
  xotira: 16%
  baza_ulanish: 80%

=== 2. Bottleneck (eng band) ===
  baza_ulanish: 80% — birinchi to'ladi

=== 3. Yuk oshadi (1000 user) ===
  baza_ulanish: 100% (chegaraga yetdi)

=== 4. Chegarani ochish ===
  baza_ulanish — bottleneck (birinchi tugaydi)
  yechim: ulanish havzasini kattalashtirish 29.7-bob
  bir bottleneck tuzatilsa — keyingisi (iterativ 29.2)
  ⭐ Bottleneck — nima birinchi cheklaydi

Nima ko'rsatdi: 2.5-bo'lim.

5. To'g'ri va noto'g'ri tushunishlar

6. Keng tarqalgan xatolar va yechimlari

1. Testsiz prodga chiqarish

# "yetarli tez" (taxmin) → prodda yiqilish            # ⚠️
# yuk testi (oldindan chegara)                         # ✅

2. O'rtacha latency (persentilsiz)

avg_latency   # yashiradi 28.10-bob                     # ⚠️
p95, p99   # haqiqat (eng yomon holat)                 # ✅

3. Noreal sharoit (kichik ma'lumot)

# 100 qator bilan test (prod million)                 # ⚠️
# real hajm, prodga o'xshash muhit                      # ✅

4. Faqat bir endpoint

# faqat /health test (real emas)                       # ⚠️
# realistik stsenariy (foydalanuvchi oqimi)             # ✅

5. Isigan kesh benchmark

# birinchi so'rov (sovuq) yoki isigan? aralash         # ⚠️
# sovuq/issiq ajratib, ko'p marta                       # ✅

6. Prodda yuk testi

# prodda 5000 virtual user (foydalanuvchi zarar)       # ⚠️
# staging (prodga o'xshash — 28.8)                       # ✅

7. Bir marta test (regressiyasiz)

# bir marta test qilib unutish                         # ⚠️
# CI'da unumdorlik test (regressiya — 28.7)              # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 29.1-dars (o'tilgan): O'lchash — benchmark asosi
• 29.2-dars (o'tilgan): Profiling — bottleneck
• 28.10-dars (o'tilgan): Monitoring — latency, persentil
• 29.6-dars (o'tilgan): Yuk taqsimlash — chegara → miqyos
• 28.7-dars (o'tilgan): CI — unumdorlik regressiya

8. Eng yaxshi amaliyotlar

1. Oldindan test (prodda emas).

2. Test turlari (load, stress, spike, soak).

3. Persentil (p95, p99 — o'rtacha emas).

4. Realistik stsenariy (foydalanuvchi oqimi).

5. Real sharoit (prod hajm, staging).

6. Monitoring bilan (bottleneck — 29.2).

7. Chegara → miqyoslash rejasi.

8. CI'da (unumdorlik regressiya — 28.7).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # nega test (oldindan)?
2.  # benchmark nima?
3.  # benchmark vs yuk testi?
4.  # load testi nima?
5.  # stress testi nima?
6.  # spike testi nima?
7.  # soak testi nima?
8.  # yuk testi o'lchovlari?
9.  # nega persentil?
10. # Locust nima?
11. # chegara nima?
12. # bottleneck nima?

Vazifa 2: Xatolarni tuzating

1.  # "yetarli tez" (taxmin)

2.  avg_latency   # persentilsiz

3.  # 100 qator (prod million)

4.  # faqat /health test

5.  # prodda 5000 user

1.  yuk testi (oldindan chegara)

2.  p95, p99 (persentil)

3.  real hajm (prod muhiti)

4.  realistik stsenariy

5.  staging (prod muhiti)

Vazifa 3: Benchmark

Modellang:

1. Yechim A
2. Yechim B
3. Taqqoslash
4. Samarali

Vazifa 4: Yuk testi

Modellang:

1. Yuk
2. Latency
3. Xatolik
4. Chegara

Vazifa 5: Test turlari

Modellang:

1. Load
2. Stress
3. Spike
4. Soak

Vazifa 6: Bottleneck

Modellang:

1. Resurslar
2. Yuk
3. Eng band
4. Chegara

Vazifa 7: O'ylash

Yuk testi tizimni prodga chiqarishdan oldin sinaydi — "yiqilishni oldindan ko'rish". Nima uchun "yukni oldindan simulyatsiya qilish" haqiqiy foydalanuvchilar bilan bilib olishdan (prodda) yaxshiroq (garchi test ham murakkab bo'lsa), va nega bu butun 29-qism (unumdorlik) ning umumiy g'oyasi — "o'lcha, taxmin qilma" ni yakunlaydi?

Nimani mustahkamlaydi: 2.1, 2.8-bo'limlar.

Xulosa

Bu darsda benchmark va yuk testini o'rgandik.

Eng muhim uch fikr:

1. Nega test va benchmark. Tizim haqiqiy yukni ko'taradimi — oldindan bilish kerak (prodda emas — kech, foydalanuvchi zarar); benchmark/yuk testi yukni simulyatsiya qiladi, chegarani topadi ("yetarli tez bo'lsa kerak" taxmin — prodda yiqiladi; test oldindan, arzon). Benchmark (nazorat sinovi) — bir amal/funksiya tezligini o'lchash/taqqoslash (timeit — ko'p marta, barqaror; eski vs yangi — optimallashtirish tasdiqlash, regressiya); farqi yuk testidan — benchmark bir amal (mikro), yuk testi butun tizim (makro).

2. Yuk testi turlari va o'lchovlari. Turlari: Load (normal/kutilgan yuk — ishlaydimi?), Stress (chegaradan oshirish — qachon yiqiladi?), Spike (birdan yuk — kutilmagan sakrash), Soak (uzoq — leak 29.9, degradatsiya). O'lchovlari 28.10-bob: latency (p95, p99 — o'rtacha aldamchi), throughput (soniyada so'rov), xatolik foizi, resurs (CPU, xotira, ulanish), concurrent users. Yuk oshganda o'lchovlar qanday o'zgaradi — chegarani ko'rsatadi. Vositalar: Locust (Python), k6, JMeter, wrk, ab.

3. Chegara, amaliyot, tayyorlik. Chegarani topish — yukni oshiraverib tizim qachon va nima uchun yiqilishi (yuk oshganda latency portlaydi, xatolik oshadi); bottleneck (29.2 — nima chegara? CPU, baza ulanish 29.7, xotira 29.9) — profiling/monitoring bilan; chegara → miqyoslash rejasi 29.6-bob. Amaliyot: real sharoit (staging, prod hajm), bosqichma yuk, persentil, realistik stsenariy, monitoring bilan, CI'da (regressiya — 28.7); tuzoqlar: noreal sharoit, faqat bir endpoint, o'rtacha, prodda test. Test — kutilmagan yukga tayyorlik (chegara bilinsa — reja, ishonch, tayyorlik — Black Friday, viral); "yiqilishni oldindan ko'r" — 29-qism ("o'lcha, taxmin qilma") yakuni (o'lchov haqiqat, intuitsiya adashtiradi); to'liq unumdorlik nazorati (o'lcha → profiling → test → optimallashtir → monitoring).

Bu bilan 29-qism (Miqyos va unumdorlik) yakunlandi: unumdorlikni o'lchash, profiling, kesh, navbatlar (Celery, Kafka/RabbitMQ), yuk taqsimlash, baza miqyosi, katta hajmdagi async, xotira optimizatsiyasi va benchmark/yuk testi. Keyingi — 30-qism: Python va boshqa tillar — Python'ni boshqa tillar (C, Rust, Go, C++, JavaScript) bilan birlashtirish: subprocess, ctypes, Cython, PyO3, gRPC va polyglot arxitektura.