Mobil tətbiqlərdə FPS: mahiyyəti, hesablanması və optimallaşdırma

FPS nədir

FPS (Frames Per Second) — kompüter qrafikası, video və mobil interfeyslərdə istifadə olunan kadr tezliyi ölçü vahididir. Hər bir kadr qısa müddət ərzində ekranda göstərilən statik təsvirdir. Kadrların sürətli dəyişməsi zamanı beyin onları davamlı hərəkət kimi qəbul edir — bu effekt görmə persistensiyası adlanır. Mobil tətbiqlər üçün FPS kritik metrikadır, çünki hər hansı buraxılmış kadr (drop) hamar animasiyanı nəzərə çarpan sıçrayışa çevirir. Tətbiq hər kadrı ciddi şəkildə vaxt büdcəsi çərçivəsində çəkməyə vaxt tapmalıdır: 60 FPS üçün 16.6 ms, 90 FPS üçün 11.1 ms, 120 FPS üçün 8.3 ms.

FPS təkcə UI üçün deyil, həm də oyunlar, video və kamera üçün ölçülür. Oyunlarda FPS səhnənin mürəkkəbliyindən, tekstur keyfiyyətindən və GPU gücündən asılıdır. Videoda FPS sabitdir (24, 30, 60 kadr/san) və məzmunla müəyyən edilir. Mobil tətbiqlərdə FPS UI kodunun effektivliyindən asılıdır: Layout-un mürəkkəbliyi, View-ların sayı, təkrar çəkmə tezliyi və GC (Garbage Collection) işi. Apple WWDC 2022 məlumatlarına görə, tətbiqdə orta FPS kolleksiyaların səmərəsiz yenilənməsi səbəbindən (reloadData əvəzinə insert/delete/dequeueReusableCell) 10–15% düşə bilər. Real vaxtda FPS ölçülməsi QA mühəndisləri və performans üzərində işləyən tərtibatçılar üçün standart təcrübədir.

FPS necə hesablanır

Mobil tətbiqdə FPS hesablanması ardıcıl kadrlar arasındakı vaxtın ölçülməsinə əsaslanır. Ən sadə düstur: FPS = 1000 / deltaTimeMs, burada deltaTimeMs əvvəlki kadrın bitməsi ilə cari kadrın bitməsi arasındakı intervaldır. Cari kadr 20 ms-də çəkilibsə, FPS = 1000 / 20 = 50. Lakin praktikada FPS hətta bir saniyə ərzində nadir hallarda sabit olur: tipik profil 12–16 ms-lik kadrları buraxılmış (jank) və ya yavaş kadrlarla (40–60 ms) növbələşdirir. Buna görə FPS 1–5 saniyə ərzində hərəkətli orta və ya kadr vaxtı paylanmasının persentilləri kimi ölçülür.

Android-də FPS Choreographer vasitəsilə hesablanır, o VSync-dən (displey sinxronizasiya impulsu) geri çağırış alır. Hər bir geri çağırış bir kadra uyğundur. Geri çağırış gəlməyibsə — kadr buraxılıb. Choreographer saniyədə dəqiq kadr sayını və buraxılmış (skipped frames) sayını ölçməyə imkan verir. iOS-da CADisplayLink analoji işləyir — displey yeni kadr çəkməyə hazır olduqda hər dəfə çağırılır. timestamp xüsusiyyəti son kadrın dəqiq vaxtını, targetTimestamp isə növbəti kadrın gözlənilən vaxtını ehtiva edir. Onların arasındakı fərq cari kadr üçün vaxt büdcəsidir.

CADisplayLink vasitəsilə FPS monitorinqi

Swift-də kod CADisplayLink vasitəsilə sadə FPS monitorinqini nümayiş etdirir. frameCount sayğacı hər çağırışda artır və saniyədə bir dəfə faktiki FPS hesablanır.

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
        }
    }
}

Niyə 60 FPS standartdır

60 FPS (60 Hz) standartı sənayedə bir neçə səbəbdən möhkəmlənib. Birincisi — fizioloji: insan gözü 50–60 Hz-dən yuxarı tezlikdə ayrı-ayrı kadrları fərqləndirmir, onları hamar hərəkət kimi qəbul edir. Bu hədd Critical Flicker Fusion (CFF) adlanır. İkincisi — tarixi: ilk katod şüa boruları (CRT) ABŞ-da (NTSC) 60 Hz və Avropada (PAL) 50 Hz tezliyində işləyirdi. Müasir LCD displeylər bu tezliyi miras alıb. Üçüncüsü — mühəndislik: UI animasiyaları üçün 60 FPS toxunma reaksiyasında millisaniyədən aşağı gecikmə təmin edir, bu mətn daxil etmə, sürüşdürmə və dartma üçün kritikdir.

Mobil tərtibatçılar üçün 60 FPS sadəcə tövsiyə deyil, kadr başına 16.6 ms-lik ciddi büdcədir. Bu büdcə renderin bütün mərhələləri arasında bölünür: Input (1–2 ms), Animation (2–3 ms), Layout (3–5 ms), Draw (3–5 ms) və Swap (1–2 ms). Əgər hər hansı mərhələ öz alt-büdcəsini aşarsa, kadr 16.6 ms-ə sığmaya bilər. Google Android Performance kadr hazırlığına 12–14 ms sərf etməyi, sistem kəsilmələri (GC, fon thread-ləri) üçün 2–4 ms ehtiyat buraxmağı tövsiyə edir. Firebase Performance məlumatlarına görə, orta FPS-i 52-dən aşağı və P99 FPS-i 30-dan aşağı olan tətbiqlər Google Play rəylərində performansla bağlı 35% daha çox şikayət alır.

FPS və Frame Time: qarşılıqlı əlaqə

FPS və Frame Time (kadr vaxtı) — eyni metrikanın iki tərəfidir və onları qarışdırmamaq vacibdir. FPS sürətdir, Frame Time gecikmədir. 60 FPS-də hər kadr 16.6 ms çəkir. 30 FPS-də — 33.3 ms. Lakin FPS qeyri-xətti metrikadır: 60-dan 30 FPS-ə düşmə kadr vaxtının 2 dəfə artması, 30-dan 20-yə düşmə isə 1.5 dəfə artması deməkdir. Buna görə profilləşdiricilər FPS deyil, Frame Time göstərir — bu, orta tezlik deyil, problemli kadrları görməyə imkan verir. Məsələn, orta 55 FPS 5% kadrın Frame Time 50–100 ms olduğunu gizlədə bilər — bu kadrlar Jank-a səbəb olur, lakin orta FPS-ə çox təsir etmir.

Performans təhlilində orta FPS-ə deyil, Frame Time histoqramına baxmaq tövsiyə olunur. Android Studio Profiler və iOS Instruments-da Frame Time şkala şəklində göstərilir, yaşıl zona — 16.6 ms-dək (60 FPS), sarı — 16.6–33.3 ms (30–60 FPS), qırmızı — 33.3 ms-dən çox (30 FPS-dən aşağı). Hər qırmızı sütun istifadəçi üçün nəzərə çarpan ləngimədir. Praktik qayda: P95 Frame Time (kadrların 95%-i X ms-ə sığır) — orta FPS-dən daha etibarlı metrikadır. Əgər P95 Frame Time 32 ms-dən (30 FPS) çox olarsa, tətbiq orta FPS = 50 olsa belə, yavaş kimi qəbul edilir.

Frame Time-ın FPS-ə çevrilməsi

Kotlin-də kadr vaxtları massivini persentillərlə FPS-ə çevirmək üçün funksiya. Yalnız orta FPS deyil, həm də detallı analiz üçün P50, P90 və P99 qaytarır.

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)]
    )
}

Yüksək FPS və yeni displeylər

90, 120 və 144 Hz displeyləri olan müasir mobil cihazlar FPS-ə yeni tələblər qoyur. Tətbiq 120 Hz displeydə 60 FPS verirsə, istifadəçi mikro-sıçrayışlar görür, çünki hər ikinci ekran yeniləmə dövrü eyni kadrı alır. 120 FPS-i saxlamaq üçün kadr büdcəsi 16.6 ms-dən 8.3 ms-ə qədər azalır — bu, iki dəfə səmərəli render kodu tələb edir. Android tərtibatçılarının məlumatlarına görə (Google I/O 2023), sabit 120 FPS-ə nail olmaq üçün: Draw dövrəsində alokasiyalardan qaçınmaq, View-ların sayını iyerarxiyada minimuma endirmək (80-dən az), ağır drawable-lardan VectorDrawable lehinə imtina etmək və mürəkkəb qrafika üçün surfaceView istifadə etmək lazımdır.

iOS-da vəziyyət analojidir: ProMotion (120 Hz) ilə iPhone Pro iki dəfə çox kadr tələb edir, lakin hər kadr üçün vaxt iki dəfə azdır. Apple qeyd edir ki, bütün animasiyalar 120 FPS-də işləməlidir — Core Animation hərəkətsiz və ya yavaş dəyişən elementlər üçün tezliyi avtomatik aşağı salır. Lakin sürüşdürmə, jest animasiyaları və keçidlər "ipək kimi" hiss üçün 120 FPS verməlidir. 60-dan 120 FPS-ə keçiddə əsas problemlər: enerji istehlakının artması (GPU üçün 25–40%), cihazın qızması və təthiq — tezlik həddindən artıq qızma səbəbindən düşdükdə. Fallback mexanizmi tətbiq etmək tövsiyə olunur: Frame Time 8.3 ms-dən stabil şəkildə çox olarsa, sistem təthiqini gözləmədən proqramlı şəkildə hədəf tezliyi 60 FPS-ə endirmək.

60 və 120 FPS arasında keçid

Android üçün Java-da kod cihazın 120 FPS-i dəstəkləyə biləcəyini müəyyən edir və render rejimini dəyişir. Dəstəklənən tezlikləri müəyyən etmək üçün Display.getMode istifadə olunur.

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;
    }
}

Tətbiqlərdə FPS optimallaşdırması

FPS optimallaşdırması profilləşdirmədən başlayaraq problemli yerlərin refaktorinqinə qədər sistematik yanaşma tələb edir. Birinci mərhələ — profilləşdirici ilə cari FPS-i ölçmək (. İkinci mərhələ — büdcəni aşan kadrları tapmaq. Android üçün bu, GPU Profiling və ya Perfetto vasitəsilə edilə bilər. iOS üçün — Core Animation şablonu ilə Instruments. Üçüncü mərhələ — səbəbləri aradan qaldırmaq: overdraw-ı azaltmaq, View-ların yerləşmə dərinliyini azaltmaq, Layout mərhələsini ConstraintLayout ilə əvəz etmək, ViewHolder Recycling əlavə etmək, ağır hesablamaları fon thread-inə köçürmək.

FPS-ə xas optimallaşdırmalara daxildir: Frame Pacing — sürətli və yavaş kadrların "paketlərindən" qaçmaq üçün vaxtı kadrlar arasında bərabər paylayan mexanizm. Android-də Choreographer.FrameCallback sabit intervalla Frame Pacing-i həyata keçirməyə imkan verir. iOS-da CADisplayLink.preferredFrameRateRange eyni şeyi edir. İkinci mexanizm — Triple Buffering: sistem iki əvəzinə üç buferdən istifadə edir, bu GPU-ya əvvəlki buferin boşalmasını gözləmədən növbəti kadrı çəkməyə başlamağa imkan verir. Android zəruri olduqda Triple Buffering-i avtomatik aktivləşdirir, lakin iOS-da tərtibatçı CAMetalLayer vasitəsilə açıq şəkildə tələb edə bilər. Üçüncü — Texture Caching: hər kadrda yenidən yükləməmək üçün bitmapların GPU yaddaşında keşləşdirilməsi.

Choreographer vasitəsilə Frame Pacing

Kotlin-də nümunə sabit 16.6 ms intervalı ilə Frame Pacing tətbiqini nümayiş etdirir. Sistem gecikmə etsə belə, bütün geri çağırışlar bərabər intervalla gəlir.

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 çəkilməsi
    }
}