Mobil ilovalarda FPS: mohiyati, hisoblash va optimallashtirish

FPS nima

FPS (Frames Per Second) — kompyuter grafikasi, video va mobil interfeyslarda qo'llaniladigan kadr chastotasi o'lchov birligidir. Har bir kadr ekranda qisqa vaqt davomida ko'rsatiladigan statik tasvirdir. Kadrlarning tez almashinuvi bilan miya ularni uzluksiz harakat sifatida qabul qiladi — bu effekt ko'rish persistensiyasi deb ataladi. Mobil ilovalar uchun FPS muhim metrikadir, chunki har qanday o'tkazib yuborilgan kadr (drop) silliq animatsiyani sezilarli qoqilishga aylantiradi. Ilova har bir kadrni vaqt byudjeti doirasida chizishga ulgurishi kerak: 60 FPS uchun 16.6 ms, 90 FPS uchun 11.1 ms, 120 FPS uchun 8.3 ms.

FPS faqat UI uchun emas, balki o'yinlar, video va kamera uchun ham o'lchanadi. O'yinlarda FPS sahnaning murakkabligiga, tekstura sifatiga va GPU quvvatiga bog'liq. Videoda FPS belgilangan (24, 30, 60 kadr/s) va kontent bilan aniqlanadi. Mobil ilovalarda FPS UI kodining samaradorligiga bog'liq: Layout murakkabligi, Viewlar soni, qayta chizish chastotasi va GC (Garbage Collection) ishi. Apple WWDC 2022 ma'lumotlariga ko'ra, ilovadagi o'rtacha FPS kolleksiyalarning samarasiz yangilanishi (insert/delete/dequeueReusableCell o'rniga reloadData) tufayli 10–15% ga tushishi mumkin. Real vaqtda FPS o'lchash QA muhandislari va unumdorlik ustida ishlaydigan dasturchilar uchun standart amaliyotdir.

FPS qanday hisoblanadi

Mobil ilovada FPS hisoblash ketma-ket kadrlar orasidagi vaqtni o'lchashga asoslanadi. Eng oddiy formula: FPS = 1000 / deltaTimeMs, bu yerda deltaTimeMs oldingi kadrning tugashi va joriy kadrning tugashi orasidagi intervaldir. Agar joriy kadr 20 ms da chizilgan bo'lsa, FPS = 1000 / 20 = 50. Biroq amalda FPS hatto bir soniya ichida ham kamdan-kam barqaror bo'ladi: tipik profil 12–16 ms lik kadrlarni o'tkazib yuborilgan (jank) yoki sekin kadrlar (40–60 ms) bilan almashlab turadi. Shuning uchun FPS 1–5 soniya davomida harakatlanuvchi o'rtacha yoki kadr vaqti taqsimotining persentillari sifatida o'lchanadi.

Androidda FPS Choreographer orqali hisoblanadi, u VSync (displey sinxronizatsiya impulsi) dan qayta chaqiruv oladi. Har bir qayta chaqiruv bitta kadrga mos keladi. Agar qayta chaqiruv kelmagan bo'lsa — kadr o'tkazib yuborilgan. Choreographer soniyadagi aniq kadrlar sonini va o'tkazib yuborilgan (skipped frames) sonini o'lchash imkonini beradi. iOSda CADisplayLink xuddi shunday ishlaydi — displey yangi kadrni chizishga tayyor bo'lganda har safar chaqiriladi. timestamp xususiyati oxirgi kadrning aniq vaqtini, targetTimestamp esa keyingi kadrning kutilgan vaqtini o'z ichiga oladi. Ularning orasidagi farq joriy kadr uchun vaqt byudjetidir.

CADisplayLink orqali FPS monitoringi

Swiftdagi kod CADisplayLink orqali oddiy FPS monitoringini namoyish etadi. frameCount hisoblagichi har bir chaqiruvda ortadi va soniyada bir marta haqiqiy FPS hisoblanadi.

class FpsCounter {

    private var displayLink: CADisplayLink?
    private var frameCount = 0
    private var lastTime = TimeInterval(0)

    func start() {
        displayLink = CADisplayLink(
            target: self,
            selector: #selector(countFrame)
        )
        displayLink?.add(to: .current,
            forMode: .common)
    }

    @objc
    private func countFrame() {
        frameCount += 1
        let now = Date().timeIntervalSince1970

        if now - lastTime >= 1.0 {
            print("FPS: \(frameCount)")
            frameCount = 0
            lastTime = now
        }
    }
}

Nima uchun 60 FPS standart

60 FPS (60 Hz) standarti sanoatda bir necha sabablarga ko'ra mustahkamlangan. Birinchisi — fiziologik: inson ko'zi 50–60 Hz dan yuqori chastotada alohida kadrlarni farqlamaydi, ularni silliq harakat sifatida qabul qiladi. Bu chegara Critical Flicker Fusion (CFF) deb ataladi. Ikkinchisi — tarixiy: birinchi katod-nur quvurlari (CRT) AQShda (NTSC) 60 Hz va Yevropada (PAL) 50 Hz chastotada ishlagan. Zamonaviy LCD displeylar bu chastotani meros qilib olgan. Uchinchisi — muhandislik: UI animatsiyalari uchun 60 FPS teginish javobida millisekunddan past kechikishni ta'minlaydi, bu matn kiritish, aylantirish va sudrab olish uchun muhimdir.

Mobil dasturchilar uchun 60 FPS shunchaki tavsiya emas, balki kadr uchun 16.6 ms lik qat'iy byudjetdir. Bu byudjet renderlashning barcha bosqichlari o'rtasida taqsimlanadi: Input (1–2 ms), Animation (2–3 ms), Layout (3–5 ms), Draw (3–5 ms) va Swap (1–2 ms). Agar biron bir bosqich o'z kichik-byudjetidan oshib ketsa, kadr 16.6 ms ga sig'masligi mumkin. Google Android Performance kadr tayyorlash uchun 12–14 ms sarflashni, tizim uzilishlari (GC, fon oqimlari) uchun 2–4 ms zaxira qoldirishni tavsiya qiladi. Firebase Performance ma'lumotlariga ko'ra, o'rtacha FPS 52 dan past va P99 FPS 30 dan past bo'lgan ilovalar Google Play sharhlarida unumdorlik bo'yicha 35% ko'proq shikoyat oladi.

FPS va Frame Time: o'zaro bog'liqlik

FPS va Frame Time (kadr vaqti) — bir metrikning ikki tomoni va ularni aralashtirmaslik muhimdir. FPS tezlik, Frame Time kechikishdir. 60 FPS da har bir kadr 16.6 ms davom etadi. 30 FPS da — 33.3 ms. Ammo FPS chiziqli bo'lmagan metrikadir: 60 dan 30 FPS ga tushish kadr vaqtining 2 barobar, 30 dan 20 ga tushish esa 1.5 barobar oshishini anglatadi. Shuning uchun profillovchilar FPS emas, balki Frame Time ni ko'rsatadi — bu o'rtacha chastotani emas, balki muammoli kadrlarni ko'rish imkonini beradi. Masalan, o'rtacha 55 FPS 5% kadrlarning Frame Time 50–100 ms ekanligini yashirishi mumkin — bu kadrlar Jank keltirib chiqaradi, ammo o'rtacha FPS ga ko'p ta'sir qilmaydi.

Unumdorlik tahlilida o'rtacha FPS ga emas, balki Frame Time histogrammasiga qarash tavsiya etiladi. Android Studio Profiler va iOS Instruments da Frame Time shkala shaklida ko'rsatiladi, yashil zona — 16.6 ms gacha (60 FPS), sariq — 16.6–33.3 ms (30–60 FPS), qizil — 33.3 ms dan ortiq (30 FPS dan past). Har bir qizil ustun foydalanuvchi uchun sezilarli kechikishdir. Amaliy qoida: P95 Frame Time (kadrlarning 95% X ms ga sig'adi) — o'rtacha FPS dan ishonchliroq metrikadir. Agar P95 Frame Time 32 ms dan (30 FPS) oshsa, ilova o'rtacha FPS = 50 bo'lsa ham sekin deb qabul qilinadi.

Frame Time ni FPS ga aylantirish

Kotlindagi kadr vaqtlari massivini persentillar bilan FPS ga aylantirish funksiyasi. Faqat o'rtacha FPS emas, balki batafsil tahlil uchun P50, P90 va P99 ni qaytaradi.

data class FpsReport(
    val average: Float,
    val p50: Float,
    val p90: Float,
    val p99: Float
)

fun List<Long>.toFpsReport(): FpsReport {
    val fpsValues = this.map { ms ->
        if (ms > 0) 1000f / ms else 0f
    }.sorted()

    return FpsReport(
        average = fpsValues.average().toFloat(),
        p50 = fpsValues[fpsValues.size / 2],
        p90 = fpsValues[(fpsValues.size * 90 / 100)],
        p99 = fpsValues[(fpsValues.size * 99 / 100)]
    )
}

Yuqori FPS va yangi displeylar

90, 120 va 144 Hz displeyli zamonaviy mobil qurilmalar FPS ga yangi talablar qo'yadi. Agar ilova 120 Hz displeyda 60 FPS bersa, foydalanuvchi mikro-qoqilishlarni ko'radi, chunki har ikkinchi ekran yangilash sikli bir xil kadrni oladi. 120 FPS ni saqlash uchun kadr byudjeti 16.6 ms dan 8.3 ms gacha kamayadi — bu ikki barobar samaraliroq renderlash kodini talab qiladi. Android dasturchilarining ma'lumotlariga ko'ra (Google I/O 2023), barqaror 120 FPS ga erishish uchun: Draw siklida alokatsiyalardan qochish, Viewlar sonini ierarxiyada minimallashtirish (80 dan kam), og'ir drawable lardan VectorDrawable foydasiga voz kechish va murakkab grafikalar uchun surfaceView dan foydalanish kerak.

iOS da vaziyat o'xshash: ProMotion (120 Hz) bilan iPhone Pro ikki barobar ko'p kadr talab qiladi, lekin har bir kadr uchun vaqt ikki barobar kam. Apple ta'kidlaydiki, barcha animatsiyalar 120 FPS da ishlashi shart emas — Core Animation harakatsiz yoki sekin o'zgaruvchi elementlar uchun chastotani avtomatik pasaytiradi. Biroq aylantirish, imo-ishora animatsiyalari va o'tishlar "ipakdek" hissiyot uchun 120 FPS berishi kerak. 60 dan 120 FPS ga o'tishdagi asosiy muammolar: energiya sarfining oshishi (GPU uchun 25–40%), qurilmaning qizishi va trottling — chastota haddan tashqari qizish tufayli tushganda. Fallback mexanizmini joriy etish tavsiya etiladi: agar Frame Time barqaror ravishda 8.3 ms dan oshsa, tizim trottlingini kutmasdan dasturiy ravishda maqsadli chastotani 60 FPS ga tushirish.

60 va 120 FPS o'rtasidagi kalit

Android uchun Java dasturi qurilma 120 FPS ni qo'llab-quvvatlay olishini aniqlaydi va renderlash rejimini o'zgartiradi. Qo'llab-quvvatlanadigan chastotalarni aniqlash uchun Display.getMode dan foydalaniladi.

class FpsModeSwitcher {

    static boolean canDo120Fps(Activity activity) {
        Display display = activity.getWindowManager()
            .getDefaultDisplay();
        for (Display.Mode mode : display.getSupportedModes()) {
            if (mode.getRefreshRate() >= 120f) {
                return true;
            }
        }
        return false;
    }
}

Ilovalarda FPS optimallashtirish

FPS optimallashtirish profillashdan boshlanib, muammoli joylarni refaktorlashgacha tizimli yondashuvni talab qiladi. Birinchi bosqich — profiller bilan joriy FPS ni o'lchash (. Ikkinchi bosqich — byudjetdan oshib ketadigan kadrlarni topish. Android uchun bu GPU Profiling yoki Perfetto orqali amalga oshirilishi mumkin. iOS uchun — Core Animation shabloni bilan Instruments. Uchinchi bosqich — sabablarni bartaraf etish: overdraw ni kamaytirish, Viewlarning joylashish chuqurligini kamaytirish, Layout bosqichini ConstraintLayout bilan almashtirish, ViewHolder Recycling qo'shish, og'ir hisoblashlarni fon oqimiga ko'chirish.

FPS ga xos optimallashtirishlarga quyidagilar kiradi: Frame Pacing — tez va sekin kadrlarning "paketlaridan" qochish uchun vaqtni kadrlar o'rtasida teng taqsimlovchi mexanizm. Androidda Choreographer.FrameCallback sobit interval bilan Frame Pacing ni amalga oshirishga imkon beradi. iOS da CADisplayLink.preferredFrameRateRange xuddi shunday qiladi. Ikkinchi mexanizm — Triple Buffering: tizim ikkita o'rniga uchta buferdan foydalanadi, bu GPU ga oldingi buferning bo'shashini kutmasdan keyingi kadrni chizishni boshlash imkonini beradi. Android kerak bo'lganda Triple Buffering ni avtomatik yoqadi, lekin iOS da dasturchi CAMetalLayer orqali aniq so'rashi mumkin. Uchinchisi — Texture Caching: har bir kadrda qayta yuklamaslik uchun bitmaplarni GPU xotirasida keshlash.

Choreographer orqali Frame Pacing

Kotlindagi misol 16.6 ms sobit interval bilan Frame Pacing implementatsiyasini namoyish etadi. Tizim kechiksa ham, barcha qayta chaqiruvlar teng interval bilan keladi.

class PacedFrameRenderer {

    private val targetDelta = 16_666_666L // 16.6 ms (60 FPS)
    private var lastFrameTime = 0L

    private val frameCallback =
        Choreographer.FrameCallback { frameTimeNanos ->
            val delta = frameTimeNanos - lastFrameTime
            if (delta >= targetDelta) {
                onFrame(delta)
                lastFrameTime = frameTimeNanos
            }
            Choreographer.getInstance()
                .postFrameCallback(this)
        }

    private fun onFrame(delta: Long) {
        // kadr chizish
    }
}