14.8-dars: Qaysi birini qachon tanlash

bosh_devor, bosh_cpu = time.perf_counter(), time.process_time()
ish()
nisbat = (time.process_time() - bosh_cpu) / (time.perf_counter() - bosh_devor)

Vaqt qayerga ketyapti?
│
├─ I/O kutish
│   ├─ Minglab ulanish / asinxron kutubxonalar bor  → asyncio
│   ├─ O'nlab-yuzlab vazifa / sinxron kutubxonalar  → ThreadPoolExecutor
│   └─ asyncio + bloklovchi kutubxona               → asyncio + to_thread
│
├─ CPU hisob (sof Python)
│   ├─ Vazifalar mustaqil, katta                    → ProcessPoolExecutor
│   ├─ Yengilroq izolyatsiya kerak (3.14)           → InterpreterPoolExecutor
│   ├─ NumPy / C kengaytma (GIL ni qo'yib yuboradi) → iplar ham yetadi
│   └─ Juda mayda vazifalar                         → avval vektorlash / paketlash
│
└─ Aralash
    └─ asyncio (I/O) + run_in_executor(ProcessPool) (CPU)

tezlashish(N) = 1 / ((1 - P) + P / N)

# Yuk turini aniqlash
nisbat = cpu_vaqti / devor_vaqti          # ≈0 → I/O, ≈1 → CPU

# I/O, sinxron kutubxonalar
with ThreadPoolExecutor(max_workers=32) as ex: ...

# I/O, minglab ulanish
async with asyncio.TaskGroup() as g: ...

# CPU
with ProcessPoolExecutor() as ex: ex.map(f, data, chunksize=...)

# Aralash
await loop.run_in_executor(jarayonlar_puli, ogir_hisob, x)

avval o'lchang: process_time / perf_counter
I/O → iplar yoki asyncio
CPU → jarayonlar (yoki subinterpretatorlar)
aralash → asyncio + ProcessPool
Amdahl: ketma-ket qism chegarani belgilaydi

"""Bir xil I/O yuki (40 ta 50 ms kutish): ketma-ket, iplar, jarayonlar, subinterpretatorlar, asyncio."""

import asyncio
import concurrent.futures as cf
import time

VAZIFALAR = 40
HA, YOQ = "✅ ha", "❌ yo'q"


def kutish(_: int) -> int:
    time.sleep(0.05)                     # tarmoq so'rovini taqlid qiladi
    return 1


async def kutish_async(_: int) -> int:
    await asyncio.sleep(0.05)
    return 1


def olchov(funksiya) -> float:
    bosh = time.perf_counter()
    funksiya()
    return time.perf_counter() - bosh


def pul_bilan(Ex, ishchilar: int) -> None:
    with Ex(max_workers=ishchilar) as ex:
        assert sum(ex.map(kutish, range(VAZIFALAR))) == VAZIFALAR


async def asinxron() -> None:
    assert sum(await asyncio.gather(*(kutish_async(i) for i in range(VAZIFALAR)))) == VAZIFALAR


def main() -> None:
    vaqtlar = {
        "ketma-ket": olchov(lambda: [kutish(i) for i in range(VAZIFALAR)]),
        "iplar (20)": olchov(lambda: pul_bilan(cf.ThreadPoolExecutor, 20)),
        "jarayonlar (8)": olchov(lambda: pul_bilan(cf.ProcessPoolExecutor, 8)),
        "subinterpretatorlar (8)": olchov(lambda: pul_bilan(cf.InterpreterPoolExecutor, 8)),
        "asyncio": olchov(lambda: asyncio.run(asinxron())),
    }
    asos = vaqtlar["ketma-ket"]

    print("=== 1. Kamida 1.5 barobar tezlashdimi ===")
    for nom, vaqt in vaqtlar.items():
        if nom != "ketma-ket":
            print(f"  {nom:24} {HA if asos / vaqt >= 1.5 else YOQ}")

    print("\n=== 2. Modellar orasida ===")
    print(f"  asyncio iplardan tez: {vaqtlar['asyncio'] < vaqtlar['iplar (20)']}")
    print(f"  iplar jarayonlardan tez: {vaqtlar['iplar (20)'] < vaqtlar['jarayonlar (8)']}")
    print(f"  asyncio ketma-ketdan kamida 10 barobar tez: {asos / vaqtlar['asyncio'] >= 10}")

    print("\n=== 3. Nega ===")
    print("  ⭐ hamma model kutishni tejaydi — GIL kutish paytida qo'yib yuboriladi")
    print("  jarayonlar: ishga tushirish narxi + faqat 8 ishchi")
    print("  iplar: 20 ishchi, lekin har biri OS ipi")
    print("  asyncio: 40 ta arzon vazifa, bitta ip")


if __name__ == "__main__":
    main()

=== 1. Kamida 1.5 barobar tezlashdimi ===
  iplar (20)               ✅ ha
  jarayonlar (8)           ✅ ha
  subinterpretatorlar (8)  ✅ ha
  asyncio                  ✅ ha

=== 2. Modellar orasida ===
  asyncio iplardan tez: True
  iplar jarayonlardan tez: True
  asyncio ketma-ketdan kamida 10 barobar tez: True

=== 3. Nega ===
  ⭐ hamma model kutishni tejaydi — GIL kutish paytida qo'yib yuboriladi
  jarayonlar: ishga tushirish narxi + faqat 8 ishchi
  iplar: 20 ishchi, lekin har biri OS ipi
  asyncio: 40 ta arzon vazifa, bitta ip

"""Bir xil CPU yuki (8 ta sof Python hisob): ketma-ket, iplar, jarayonlar, subinterpretatorlar, asyncio."""

import asyncio
import concurrent.futures as cf
import sys
import time

VAZIFALAR = 8
HA, YOQ = "✅ ha", "❌ yo'q"


def hisob(_: int = 0) -> int:
    s = 0
    for i in range(6_000_000):
        s += i * i
    return s


KUTILGAN = 0                             # main() da hisoblanadi — ishchilar qayta hisoblamasin


def olchov(funksiya) -> float:
    bosh = time.perf_counter()
    funksiya()
    return time.perf_counter() - bosh


def pul_bilan(Ex) -> None:
    with Ex(max_workers=VAZIFALAR) as ex:
        assert all(n == KUTILGAN for n in ex.map(hisob, range(VAZIFALAR)))


async def asinxron() -> None:
    async def vazifa() -> int:
        return hisob()                   # await yo'q — loop band
    natijalar = await asyncio.gather(*(vazifa() for _ in range(VAZIFALAR)))
    assert all(n == KUTILGAN for n in natijalar)


def main() -> None:
    global KUTILGAN
    KUTILGAN = hisob()
    print(f"GIL yoqilgan: {sys._is_gil_enabled()}")
    vaqtlar = {
        "ketma-ket": olchov(lambda: [hisob() for _ in range(VAZIFALAR)]),
        "iplar": olchov(lambda: pul_bilan(cf.ThreadPoolExecutor)),
        "jarayonlar": olchov(lambda: pul_bilan(cf.ProcessPoolExecutor)),
        "subinterpretatorlar": olchov(lambda: pul_bilan(cf.InterpreterPoolExecutor)),
        "asyncio": olchov(lambda: asyncio.run(asinxron())),
    }
    asos = vaqtlar["ketma-ket"]

    print("\n=== 1. Kamida 1.5 barobar tezlashdimi ===")
    for nom, vaqt in vaqtlar.items():
        if nom != "ketma-ket":
            print(f"  {nom:20} {HA if asos / vaqt >= 1.5 else YOQ}")

    print("\n=== 2. Tahlil ===")
    print(f"  iplar ketma-ketdan tez emas (GIL): {vaqtlar['iplar'] > asos * 0.7}")
    print(f"  asyncio ketma-ketdan tez emas: {vaqtlar['asyncio'] > asos * 0.7}")
    print(f"  jarayonlar va subinterpretatorlar parallel: "
          f"{asos / vaqtlar['jarayonlar'] >= 1.5 and asos / vaqtlar['subinterpretatorlar'] >= 1.5}")

    print("\n=== 3. Xulosa ===")
    print("  ⭐ I/O yukida g'olib bo'lgan asyncio bu yerda foydasiz")
    print("  ⭐ har interpretatorning o'z GIL i bor — shuning uchun subinterpretatorlar parallel")
    print("  ⚠️ free-threaded (3.14t) buildda iplar ham tezlashardi")


if __name__ == "__main__":
    main()

GIL yoqilgan: True

=== 1. Kamida 1.5 barobar tezlashdimi ===
  iplar                ❌ yo'q
  jarayonlar           ✅ ha
  subinterpretatorlar  ✅ ha
  asyncio              ❌ yo'q

=== 2. Tahlil ===
  iplar ketma-ketdan tez emas (GIL): True
  asyncio ketma-ketdan tez emas: True
  jarayonlar va subinterpretatorlar parallel: True

=== 3. Xulosa ===
  ⭐ I/O yukida g'olib bo'lgan asyncio bu yerda foydasiz
  ⭐ har interpretatorning o'z GIL i bor — shuning uchun subinterpretatorlar parallel
  ⚠️ free-threaded (3.14t) buildda iplar ham tezlashardi

"""1 000 ip va 1 000 vazifa yaratish narxi; 10 000 bir vaqtdagi kutish; Amdahl qonuni jadvali."""

import asyncio
import threading
import time


def olchov(funksiya) -> float:
    bosh = time.perf_counter()
    funksiya()
    return time.perf_counter() - bosh


def ming_ip() -> None:
    iplar = [threading.Thread(target=time.sleep, args=(0,)) for _ in range(1_000)]
    for ip in iplar:
        ip.start()
    for ip in iplar:
        ip.join()


async def ming_vazifa() -> None:
    await asyncio.gather(*(asyncio.sleep(0) for _ in range(1_000)))


async def on_ming_kutish() -> None:
    await asyncio.gather(*(asyncio.sleep(0.2) for _ in range(10_000)))


def amdahl(parallel_qism: float, yadrolar: float) -> float:
    return 1 / ((1 - parallel_qism) + parallel_qism / yadrolar)


def main() -> None:
    print("=== 1. Yaratish narxi ===")
    ip_vaqti = olchov(ming_ip)
    vazifa_vaqti = olchov(lambda: asyncio.run(ming_vazifa()))
    print(f"  1 000 vazifa 1 000 ipdan kamida 5 barobar arzon: {ip_vaqti / vazifa_vaqti >= 5}")

    print("\n=== 2. 10 000 ta bir vaqtdagi kutish ===")
    vaqt = olchov(lambda: asyncio.run(on_ming_kutish()))
    print(f"  10 000 ta 0.2 s lik kutish 1 s dan kam vaqtda tugadi: {vaqt < 1.0}")
    print("  ⭐ 10 000 ip bilan bu OS chegaralariga urilardi")

    print("\n=== 3. Amdahl qonuni ===")
    print(f"  {'parallel qism':>14} {'4 yadro':>9} {'16 yadro':>9} {'1000 yadro':>11}")
    for p in (0.5, 0.9, 0.95, 0.99):
        qator = "".join(f"{amdahl(p, n):>9.2f}×" for n in (4, 16))
        print(f"  {p:>13.0%} {qator} {amdahl(p, 1000):>10.2f}×")

    print("\n=== 4. Amdahl nima deydi ===")
    print(f"  90% parallel kod, 16 yadro: {amdahl(0.9, 16):.2f}× — 16× emas")
    print(f"  ketma-ket qismni 10% dan 5% ga tushirish: {amdahl(0.9, 16):.2f}× → {amdahl(0.95, 16):.2f}×")
    print(f"  yadrolarni 16 dan 32 ga oshirish:         {amdahl(0.9, 16):.2f}× → {amdahl(0.9, 32):.2f}×")
    print("  ⭐ ketma-ket qismni qisqartirish yadro qo'shishdan foydaliroq")


if __name__ == "__main__":
    main()

=== 1. Yaratish narxi ===
  1 000 vazifa 1 000 ipdan kamida 5 barobar arzon: True

=== 2. 10 000 ta bir vaqtdagi kutish ===
  10 000 ta 0.2 s lik kutish 1 s dan kam vaqtda tugadi: True
  ⭐ 10 000 ip bilan bu OS chegaralariga urilardi

=== 3. Amdahl qonuni ===
   parallel qism   4 yadro  16 yadro  1000 yadro
            50%      1.60×     1.88×       2.00×
            90%      3.08×     6.40×       9.91×
            95%      3.48×     9.14×      19.63×
            99%      3.88×    13.91×      90.99×

=== 4. Amdahl nima deydi ===
  90% parallel kod, 16 yadro: 6.40× — 16× emas
  ketma-ket qismni 10% dan 5% ga tushirish: 6.40× → 9.14×
  yadrolarni 16 dan 32 ga oshirish:         6.40× → 7.80×
  ⭐ ketma-ket qismni qisqartirish yadro qo'shishdan foydaliroq

"""CPU/devor nisbati bilan yuk turini aniqlash; aralash quvur: iplar, asyncio, asyncio + ProcessPool."""

import asyncio
import concurrent.futures as cf
import time

HUJJATLAR = 16


def yuk_turi(funksiya) -> str:
    bosh_devor, bosh_cpu = time.perf_counter(), time.process_time()
    funksiya()
    nisbat = (time.process_time() - bosh_cpu) / (time.perf_counter() - bosh_devor)
    if nisbat < 0.2:
        return "I/O"
    if nisbat > 0.7:
        return "CPU"
    return "aralash"


def tahlil(matn: str) -> int:
    """CPU qismi: sof Python hisob."""
    s = 0
    for i in range(1_200_000):
        s += (i * len(matn)) % 7
    return s


def yuklab_ol_sinxron(i: int) -> str:
    time.sleep(0.1)                      # I/O qismi
    return f"hujjat-{i}"


async def yuklab_ol(i: int) -> str:
    await asyncio.sleep(0.1)
    return f"hujjat-{i}"


def faqat_iplar() -> list[int]:
    def toliq(i: int) -> int:
        return tahlil(yuklab_ol_sinxron(i))
    with cf.ThreadPoolExecutor(max_workers=HUJJATLAR) as ex:
        return list(ex.map(toliq, range(HUJJATLAR)))


async def faqat_asyncio() -> list[int]:
    async def toliq(i: int) -> int:
        return tahlil(await yuklab_ol(i))          # ⚠️ hisob loopni bloklaydi
    return list(await asyncio.gather(*(toliq(i) for i in range(HUJJATLAR))))


async def gibrid() -> list[int]:
    loop = asyncio.get_running_loop()
    with cf.ProcessPoolExecutor(max_workers=8) as pul:
        async def toliq(i: int) -> int:
            matn = await yuklab_ol(i)                        # I/O — loopda
            return await loop.run_in_executor(pul, tahlil, matn)  # CPU — jarayonda
        return list(await asyncio.gather(*(toliq(i) for i in range(HUJJATLAR))))


def aralash_ish() -> None:
    for i in range(3):
        yuklab_ol_sinxron(i)
    tahlil("hujjat-0")


def olchov(funksiya) -> tuple[list[int], float]:
    bosh = time.perf_counter()
    natija = funksiya()
    return natija, time.perf_counter() - bosh


def main() -> None:
    print("=== 1. Yuk turini o'lchab aniqlash ===")
    print(f"  yuklab olish: {yuk_turi(lambda: [yuklab_ol_sinxron(i) for i in range(3)])}")
    print(f"  tahlil:       {yuk_turi(lambda: tahlil('hujjat-0'))}")
    print(f"  ikkalasi:     {yuk_turi(aralash_ish)}")

    print("\n=== 2. Aralash quvur, uch arxitektura ===")
    kutilgan = [tahlil(f"hujjat-{i}") for i in range(HUJJATLAR)]
    iplar, iplar_vaqti = olchov(faqat_iplar)
    asinx, asinx_vaqti = olchov(lambda: asyncio.run(faqat_asyncio()))
    gib, gib_vaqti = olchov(lambda: asyncio.run(gibrid()))
    print(f"  uchala natija to'g'ri: {iplar == kutilgan and asinx == kutilgan and gib == kutilgan}")
    print(f"  gibrid faqat iplardan tez: {gib_vaqti < iplar_vaqti}")
    print(f"  gibrid faqat asyncio dan tez: {gib_vaqti < asinx_vaqti}")
    print(f"  gibrid eng sekinidan kamida 2 barobar tez: {max(iplar_vaqti, asinx_vaqti) / gib_vaqti >= 2}")

    print("\n=== 3. Nega ===")
    print("  faqat iplar:   yuklash parallel, tahlil GIL da navbat kutadi")
    print("  faqat asyncio: tahlil loopni bloklaydi — yuklash ham to'xtaydi")
    print("  gibrid:        yuklash loopda, tahlil 8 ta jarayonda parallel")

    print("\n=== 4. Qaror ===")
    for vazifa, tanlov in [
        ("10 000 WebSocket ulanishi", "asyncio"),
        ("50 ta API ga sinxron kutubxona bilan", "ThreadPoolExecutor"),
        ("1 mln qatorni sof Python da hisoblash", "ProcessPoolExecutor"),
        ("veb-xizmat + og'ir hisobot", "asyncio + ProcessPoolExecutor"),
        ("NumPy matritsa amallari", "iplar yoki vektorlash (GIL qo'yib yuboriladi)"),
    ]:
        print(f"  {vazifa:40} → {tanlov}")


if __name__ == "__main__":
    main()

=== 1. Yuk turini o'lchab aniqlash ===
  yuklab olish: I/O
  tahlil:       CPU
  ikkalasi:     aralash

=== 2. Aralash quvur, uch arxitektura ===
  uchala natija to'g'ri: True
  gibrid faqat iplardan tez: True
  gibrid faqat asyncio dan tez: True
  gibrid eng sekinidan kamida 2 barobar tez: True

=== 3. Nega ===
  faqat iplar:   yuklash parallel, tahlil GIL da navbat kutadi
  faqat asyncio: tahlil loopni bloklaydi — yuklash ham to'xtaydi
  gibrid:        yuklash loopda, tahlil 8 ta jarayonda parallel

=== 4. Qaror ===
  10 000 WebSocket ulanishi                → asyncio
  50 ta API ga sinxron kutubxona bilan     → ThreadPoolExecutor
  1 mln qatorni sof Python da hisoblash    → ProcessPoolExecutor
  veb-xizmat + og'ir hisobot               → asyncio + ProcessPoolExecutor
  NumPy matritsa amallari                  → iplar yoki vektorlash (GIL qo'yib yuboriladi)

async def ishla(x): return ogir_hisob(x)          # ❌ loop bloklanadi
await loop.run_in_executor(pul, ogir_hisob, x)    # ✅

ProcessPoolExecutor().map(requests.get, urllar)   # ❌ ortiqcha narx
ThreadPoolExecutor(32).map(requests.get, urllar)  # ✅

# ❌ "bu sekin, parallel qilamiz"
# ✅ process_time / perf_counter bilan yuk turini aniqlang

ThreadPoolExecutor(max_workers=10_000)            # ❌

ex.map(kichik, katta_royxat)                      # ❌ chunksize=1
ex.map(kichik, katta_royxat, chunksize=10_000)    # ✅

# ❌ natijalarni yig'ish bitta ipda 50% vaqt oladi — yadro qo'shish yordam bermaydi

async def f(): await asyncio.to_thread(umumiy_royxat.append, x)  # ⚠️ iplar poygasi

ProcessPoolExecutor().map(np.dot, ...)            # ⚠️ katta massivlarni pickle qilish
# ✅ vektorlash yoki iplar — NumPy GIL ni qo'yib yuboradi

import asyncio, concurrent.futures as cf, sys, time
1.  def amdahl(p, n): return 1 / ((1 - p) + p / n)
    print(round(amdahl(0.5, 1_000_000), 2))
2.  def amdahl(p, n): return 1 / ((1 - p) + p / n)
    print(round(amdahl(1.0, 8), 2))
3.  def amdahl(p, n): return 1 / ((1 - p) + p / n)
    print(round(amdahl(0.0, 8), 2))
4.  print(hasattr(cf, "InterpreterPoolExecutor"))
5.  print(callable(getattr(sys, "_is_gil_enabled", None)))
6.  b = time.process_time()
    time.sleep(0.1)
    print(time.process_time() - b < 0.05)
7.  print(issubclass(cf.ThreadPoolExecutor, cf.Executor),
          issubclass(cf.ProcessPoolExecutor, cf.Executor))
8.  async def m(): return await asyncio.to_thread(sum, [1, 2, 3])
    print(asyncio.run(m()))
9.  async def m():
        loop = asyncio.get_running_loop()
        return await loop.run_in_executor(None, pow, 2, 10)
    print(asyncio.run(m()))
10. with cf.ThreadPoolExecutor(4) as ex:
        print(list(ex.map(len, ["a", "bb", "ccc"])))
11. def amdahl(p, n): return 1 / ((1 - p) + p / n)
    print(amdahl(0.9, 16) < amdahl(0.95, 16))
12. print(issubclass(cf.InterpreterPoolExecutor, cf.ThreadPoolExecutor))

1.  Telegram bot: 20 000 foydalanuvchi, har xabarga bazadan o'qish
2.  5 GB CSV faylni qatorma-qator sof Python bilan tozalash
3.  300 ta saytni har 5 daqiqada tekshiradigan monitoring (requests kutubxonasi)
4.  Video fayllarni ffmpeg bilan qayta kodlash (tashqi dastur)
5.  FastAPI xizmati: har so'rovda 2 soniyalik PDF hisobot yaratish