CPU Rendering: bu nima, tamoyillari va dasturiy renderlash qanday ishlaydi

CPU Rendering nima?

CPU Rendering — grafik konveyerning barcha bosqichlari matematik hisob-kitoblar yordamida markaziy protsessorda bajariladigan tasvirni shakllantirish usuli. Rasterlashtirish va teksturalash ixtisoslashtirilgan bloklarga kiritilgan GPU dan farqli o‘laroq, CPU ularni universal SSE/NEON ko‘rsatmalari orqali bajaradi.

Tarixiy jihatdan, barcha renderlash dasturiy edi — birinchi grafik interfeyslar (Xerox Alto, 1973) va 3D o‘yinlar (Quake, 1996) CPU da renderlangan. «Software renderer» atamasi CPU Rendering sinonimi sifatida mustahkamlangan. Uskuna tezlashtirishga o‘tish 1990-yillarning oxirida arzon 3D tezlatkichlarning paydo bo‘lishi bilan boshlandi, ammo dasturiy renderlash zaxira mexanizmi sifatida qoldi.

Akamai (2025) ma’lumotlariga ko‘ra, CPU Rendering mobil veb seanslarning 35 foizida asosiy renderlash rejimi sifatida qo‘llaniladi — kuchsiz qurilmalarda, emulyatorlarda va GPU tezlashtirish o‘chirilganida. iOS va Android platformalarida UI frameworklari (UIKit, Android View) dastlabki bir necha kadrni har doim GPU buyruqlari ishga tushirilgunga qadar CPU da renderlaydi.

Zamonaviy protsessorlar GPU parallelligini qisman taqlid qiluvchi SIMD ko‘rsatmalarini (SSE4.2, AVX-512, ARM NEON) qo‘llab-quvvatlaydi. Biroq, yadrolarning jismoniy soni (4–12) va ixtisoslashtirilgan rasterlashtirish bloklarining yo‘qligi murakkab grafikada CPU Rendering unumdorligini cheklaydi.

Dasturiy renderlash bosqichlari

Dasturiy konveyer uskuna konveyeri bilan bir xil bosqichlarni o‘z ichiga oladi: uchlar transformatsiyasi, kesish, rasterlashtirish, teksturalash va piksellarni chiqarish. Farq shundaki, har bir bosqich qattiq GPU bloklari orqali emas, balki C++ yoki assembler kodi orqali dasturiy tarzda amalga oshiriladi.

CPU Rendering da uchlar transformatsiyasi matritsalarni ko‘paytirish orqali bajariladi — proyeksiya va modellashtirish uchun 4x4. 10 000 ko‘pburchakda bu kadr boshiga 40 000 vektor ko‘paytirishni tashkil qiladi — optimallashtirilgan kod bilan CPU 5–10 ms da uddasidan chiqadigan yuk. Rasterlashtirish eng og‘ir bosqich bo‘lib, har bir uchburchak uchun piksel qoplamasini hisoblashni talab qiladi.

Mobil protsessorlarda ARM NEON 128 bitli vektor ko‘rsatmalari orqali dasturiy renderlashni tezlashtiradi. ARM (2025) ma’lumotlariga ko‘ra, NEON optimallashtirilgan software renderer bir xil takt chastotasida Cortex-X4 da skalyar tatbiqdan 3–4 barobar tezroq ishlaydi.

Dasturiy renderlash qanday ishlaydi?

Dasturiy renderlash CPU da sahna tayyorlash bilan boshlanadi: geometriya (uchlar, ko‘pburchaklar) matritsa operatsiyalari orqali dunyo koordinatalaridan ekran koordinatalariga o‘zgartiriladi. So‘ngra kesish amalga oshiriladi — kamera ko‘rish maydonidan tashqaridagi geometriya olib tashlanadi.

CPU rasterlashtirishi har bir uchburchakni skanerlash chizig‘i (scanline) algoritmi yoki baritsentrik koordinatalar orqali piksellarga ajratadi. Har bir piksel uchun teksturalar, yoritish va shaffoflikni hisobga olgan holda rang hisoblanadi. Natija framebuffer — operativ xotiradagi piksel massiviga yoziladi.

GPU renderlashdan asosiy farq — piksel darajasida parallellikning yo‘qligi. CPU piksellarni ketma-ket yoki 4–8 yadro orqali kichik parallellik bilan qayta ishlaydi. Teksturalash bilan 1080p kadr (2 million piksel) uchun CPU da 15–30 ms, GPU da esa 2–5 ms talab qilinadi.

// Bitta uchburchakning soddalashtirilgan CPU rasterlashtirishi
void rasterizeTriangle(uint32_t* buffer, int width,
    Vertex v0, Vertex v1, Vertex v2) {
    int minX = max(0, min(v0.x, v1.x, v2.x));
    int maxX = min(width, max(v0.x, v1.x, v2.x));
    int minY = max(0, min(v0.y, v1.y, v2.y));
    for (int y = minY; y <= maxY; y++) {
        for (int x = minX; x <= maxX; x++) {
            if (pixelInTriangle(x, y, v0, v1, v2)) {
                buffer[y * width + x] = 0xFF3498DB;
            }
        }
    }
}

Funksiya uchburchakning bounding box ini aylanib chiqadi va har bir pikselning tegishliligini baritsentrik koordinatalar orqali tekshiradi. Millionlab piksellar uchun bunday sikl CPU da millisekundlarda bajariladi, ammo minglab uchburchakli murakkab sahnalarda vaqt chiziqli ravishda oshadi.

CPU va GPU renderlashni taqqoslash

CPU Rendering va GPU Rendering o‘rtasidagi farq protsessorlar arxitekturasi bilan belgilanadi. CPU tarmoqlanishni bashorat qilish bilan ketma-ket vazifalar uchun, GPU esa minglab iplar bilan ommaviy parallellik uchun optimallashtirilgan. Bu fundamental farq har bir yondashuvning qo‘llanish sohalarini belgilaydi.

CPU Rendering determinizmda ustunlik qiladi — bir xil kirish ma’lumotlari har doim bir xil natijani beradi. Bu har bir piksel dizaynga mos kelishi kerak bo‘lgan UI frameworklari uchun muhimdir. GPU turli drayverlarda suzuvchi nuqtani yaxlitlash xususiyatlari tufayli xatolarga yo‘l qo‘yishi mumkin.

Past murakkablikdagi 2D grafik (100–500 primitiv) uchun CPU Rendering ko‘pincha GPU dan tezroq bo‘ladi, chunki ma’lumotlarni magistral orqali uzatish va shader kompilyatsiyasi uchun qo‘shimcha xarajatlar yo‘q. Google Android Team (2025) ma’lumotlariga ko‘ra, Android View tizimida dasturiy renderlash odatdagi ekran uchun 2–3 ms, GPU da uskuna tezlashtirish bilan esa 3–5 ms davom etadi.

CPU Rendering qayerda qo‘llaniladi

Dasturiy renderlash GPU mavjud bo‘lmagan, ortiqcha bo‘lgan yoki kerakli determinizmni ta’minlamaydigan stsenariylarda talab qilinishicha qolmoqda. Zamonaviy rivojlanishda CPU Renderingning asosiy qo‘llanish sohalarini ko‘rib chiqamiz.

UI frameworklari va kadr tayyorlash

Android View tizimi barcha UI elementlarini CPU da renderlaydi, so‘ngra natijani kompozitsiya uchun GPU ga uzatadi. Har bir View onDraw(Canvas)ni chaqiradi, u CPU orqali Bitmap da chizadi. Shundan keyin HWUI qatlamlarni GPU da kompozitsiya qiladi. Bu GPU drayveridan qat’i nazar UI ning deterministik xatti-harakatini ta’minlaydi.

iOS da UIKit ham CPU renderlash bilan boshlanadi. Core Animation CALayer ni CPU da backing store da renderlaydi, so‘ngra teksturalarni GPU ga yuboradi. WWDC 2024 ma’lumotlariga ko‘ra, dasturiy bosqich kadr renderlash vaqtining 30–50 foizini egallaydi, qolgani GPU kompozitsiyasidir.

SVG va vektor grafikasi

SVG renderlash an’anaviy ravishda CPU da bajariladi, chunki murakkab Bezier egri chiziqlari va ularni to‘ldirishni qurishni talab qiladi. librsvg va Skia kabi kutubxonalar SVG ni CPU da qayta ishlaydi, egri chiziqlarni uchburchaklarga bo‘lib va ularni bo‘yab. Google Chrome Team (2025) ma’lumotlariga ko‘ra, CPU dagi Skia SVG ikonkalarni zamonaviy mobil protsessorlarda 0.3–1.5 ms da renderlaydi.

PDF renderlash

PDF hujjatlari murakkab ichki grafikani o‘z ichiga oladi: shriftlar, vektor elementlari, rastr tasvirlar va transformatsiyalar. Mobil ilovalar PDF ni PDFKit (iOS) va PdfRenderer (Android) kabi frameworklar orqali CPU da renderlaydi. Ko‘rsatish aniqligi va PDF 2.0 standartini qo‘llab-quvvatlash har bir elementni dasturiy qayta ishlashni talab qiladi.

Mobil platformalarda CPU Rendering

Mobil platformalar CPU Rendering ni ARM arxitekturasi va cheklangan energiya sarfini hisobga olgan holda amalga oshiradi. Android va iOS da dasturiy renderlash qanday ishlashini ko‘rib chiqamiz.

Android: CPU da Canvas

Android Canvas uskuna tezlashtirish o‘chirilganida to‘liq CPU da ishlaydi. Canvas sinfi Skia — Google ning 2D kutubxonasi orqali bajariladigan primitivlarni chizish usullarini o‘z ichiga oladi. Skia dasturiy va GPU backendlarini qo‘llab-quvvatlaydi va hardwareAccelerated bayrog‘i bilan o‘tadi.

Dasturiy Canvas operativ xotirada Bitmap yaratadi, Skia Software Renderer orqali unda buyruqlarni chizadi va so‘ngra ekranga ko‘rsatadi. Barcha operatsiyalar optimallashtirish uchun NEON ko‘rsatmalaridan foydalangan holda CPU da bajariladi. Skia Team (2025) ma’lumotlariga ko‘ra, NEON tezlashtirish blend va maskalash operatsiyalari uchun 40–60% unumdorlik oshishini beradi.

// Bitmap orqali dasturiy renderlash
val bitmap = Bitmap.createBitmap(200, 200, Bitmap.Config.ARGB_8888)
val canvas = Canvas(bitmap)
val paint = Paint().apply {
    color = Color.RED
    textSize = 24f
}
canvas.drawText("CPU Render", 10f, 50f, paint)
imageView.setImageBitmap(bitmap)

Bitmap CPU xotirasida yaratiladi, unda chizish buyruqlari bajariladi, so‘ngra tayyor tasvir ImageView orqali ko‘rsatiladi. Bunday yondashuv har bir piksel ustidan to‘liq nazorat muhim bo‘lgan watermarking, grafiklar va dinamik tasvirlar uchun qo‘llaniladi.

iOS: CPU da Core Graphics

Core Graphics — Apple ning asosan CPU da ishlaydigan rastr va vektor grafikasi uchun frameworki. CGContext barcha chizish operatsiyalarini Apple ning yuqori optimallashtirilgan kutubxonalaridan foydalanib dasturiy rejimda bajaradi. Core Graphics 25 yillik tarixga ega Quartz 2D dvigatelini qo‘llab-quvvatlaydi.

iOS da Core Graphics natijani GPU da kompozitsiya uchun Core Animation ga uzatadi. Apple Engineering (2025) ma’lumotlariga ko‘ra, Core Graphics UIKit da UI chizishning 80 foizini CPU da qayta ishlaydi, Metal kompozitsiyasi esa tayyor teksturalarni GPU da to‘playdi. UIGraphicsImageRenderer CPU da rastr tasvirlarni renderlash uchun zamonaviy o‘ramdir.

Dasturiy renderlashni optimallashtirish

CPU Rendering ni optimallashtirish unumdorlik uchun muhimdir, chunki dasturiy renderlash UI frameworklarida CPU siklilarining asosiy iste’molchisidir. Dasturiy renderlashni tezlashtirishning asosiy usullarini ko‘rib chiqamiz.

Natijani keshga olish

Eng samarali usul o‘zgarmagan narsani qayta chizmaslikdir. Agar kontent statik bo‘lsa, uni bir marta Bitmap yoki CGLayer da renderlang va tayyor natijani nusxalang. Android da bu keshga olingan Bitmap bilan View.setLayerType(LAYER_TYPE_SOFTWARE) orqali amalga oshiriladi. iOS da — drawsAsynchronously va CALayer.shouldRasterize orqali.

Qayta chizish maydonini minimallashtirish

Iflos to‘rtburchaklar (dirty rectangles) dan foydalaning — ekranning qaysi maydonlari o‘zgarganini kuzating va faqat ularni qayta chizing. Android ViewSystem avtomatik ravishda invalidated region ni hisoblaydi. iOS CALayer qayta chizish maydonini cheklash uchun setNeedsDisplayInRect dan foydalanadi.

Bit operatsiyalari va SSE/NEON

Piksel operatsiyalari (blend, maskalash) uchun CPU ning SIMD ko‘rsatmalaridan foydalaning. Android Skia ARM protsessorlari uchun avtomatik ravishda NEON dan foydalanadi. iOS Core Graphics Accelerate framework orqali vektorlashtirilgan. Google (2025) ma’lumotlariga ko‘ra, Skia da NEON optimallashtirilgan blend operatsiyalari skalyar koddan 3–5 barobar tezroq bajariladi.

// NEON optimallashtirilgan piksel aralashtirish (ARM)
#include <arm_neon.h>
void blendNEON(uint32_t* dst, const uint32_t* src, int count) {
    for (int i = 0; i < count; i += 4) {
        uint8x16_t a = vld1q_u8((uint8_t*)(src + i));
        uint8x16_t b = vld1q_u8((uint8_t*)(dst + i));
        uint8x16_t r = vhaddq_u8(a, b);
        vst1q_u8((uint8_t*)(dst + i), r);
    }
}

NEON ko‘rsatmalari bir operatsiyada 16 piksel (128 bit) ni qayta ishlaydi. ARM Cortex-X4 konveyerlash bilan birgalikda bu dasturiy nusxalash va aralashtirishda sekundiga 500 million piksel o‘tkazish qobiliyatini beradi — 60 FPS bilan FullHD ekran uchun yetarli.