VSync — vad är det, funktionsprincip och konfiguration

Vad är VSync

VSync (Vertical Synchronization) — en hårdvaru-mjukvarumekanism som tvingar GPU att vänta på den vertikala släckningssignalen (VBlank) innan en ny bildruta visas. Utan VSync kan GPU skicka bildrutor när som helst, även när displayen håller på att rendera den aktuella bildrutan, vilket leder till bildrivning längs en horisontell linje.

På mobila enheter är VSync implementerat på nivån av grafisk drivrutin och operativsystem. iOS använder VBlank-synkronisering via Metal, Android via SurfaceFlinger och BufferQueue. Med vertikal synkronisering aktiverad kan applikationens FPS inte överstiga displayens uppdateringsfrekvens — 60, 90 eller 120 Hz beroende på enhetsmodell.

Termen vertikal synkronisering kommer från funktionsmekanismen hos CRT-monitorer, där elektronstrålen ritade bilden rad för rad uppifrån och ner. Efter slutförandet av en bildruta återvände strålen till det övre vänstra hörnet — detta ögonblick kallades vertikal släckning. Moderna LCD- och OLED-displayer har behållit denna term, även om de fysiskt fungerar annorlunda.

Hur vertikal synkronisering fungerar

GPU renderar bildrutor i back buffer, medan displayen läser från front buffer. VSync garanterar att växling av buffrar (swap) endast sker vid VBlank-ögonblicket — när displayen har slutfört visningen av den aktuella bildrutan och är redo för nästa. Denna mekanism kallas dubbelbuffring med synkronisering via VBlank.

Mekanismen för dubbelbuffring

Dubbelbuffring använder två buffrar: front buffer, som visas på skärmen, och back buffer, där GPU skriver den aktuella bildrutan. När bildrutan är klar byter buffrarna plats. Med VSync aktiverat fördröjs detta byte till närmaste VBlank. GPU är inaktiv om bildrutan är klar före VBlank, vilket minskar prestanda men eliminerar tearing.

// OpenGL — aktivering av VSync via WGL_EXT_swap_control
HDC hdc = wglGetCurrentDC();
PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT =
    reinterpret_cast<PFNWGLSWAPINTERVALEXTPROC>(
        wglGetProcAddress("wglSwapIntervalEXT"));
wglSwapIntervalEXT(1); // 1 = VSync aktiverad, 0 = avaktiverad

Väntetid för VBlank

VBlank — ett kort tidsintervall mellan den sista raden i den aktuella bildrutan och den första raden i nästa. I detta ögonblick uppdaterar displayen inte pixlar och byte av buffrar sker utan artefakter. Varaktigheten av VBlank beror på uppdateringsfrekvensen: vid 60 Hz på en 1080p-display varar VBlank ungefär 1.4 ms. Om GPU inte hinner slutföra renderingen före VBlank hoppas bildrutan över och displayen visar den föregående bildrutan ytterligare en cykel — detta upplevs som hackande (stutter).

Trippelbuffring löser problemet med inaktiv GPU genom att lägga till en tredje buffer. GPU kan omedelbart börja rendera nästa bildruta, även om en av back buffrarna väntar på VBlank. Detta ökar FPS med VSync, men lägger till en extra bildrutas fördröjning. På mobila enheter används trippelbuffring i vissa spelmotorer och i Vulkan via Mailbox-läge.

Huvudsakliga problem utan VSync

AVstängd VSync ger maximal FPS och minimal input lag, men till priset av visuella artefakter. För mobila spel och applikationer med smidig animation är valet mellan VSync och att stänga av det en kompromiss mellan bildskärpa och kontrollrespons.

Bildrivning (Screen Tearing)

Screen tearing — en horisontell rivning där den övre delen av skärmen visar föregående bildruta och den nedre delen redan nästa. Detta händer när GPU byter buffrar mitt i displayens svepcykel. På mobila enheter är tearing särskilt märkbart vid snabb scrollning eller i dynamiska scener med hög bildfrekvens. OLED-displayer med sin omedelbara respons gör tearing mer kontrastrikt jämfört med LCD.

Intensiteten av tearing beror på förhållandet mellan FPS och uppdateringsfrekvens. Vid 60 FPS på en 60 Hz-skärm visas tearing som en statisk linje, och vid 300 FPS på 60 Hz — som flera vågiga rivningar som rör sig uppifrån och ner. Ju högre FPS i förhållande till uppdateringsfrekvensen, desto fler rivningar och desto mer synliga är de.

Inmatningsfördröjning (Input Lag)

Input lag vid VSync — fördröjningen mellan att trycka på en knapp och att resultatet visas på skärmen. Vertikal synkronisering lägger i genomsnitt till en bildrutas fördröjning (16.7 ms vid 60 Hz), och vid trippelbuffring — upp till två bildrutor. För vardagliga applikationer är denna fördröjning omärkbar, men för shooters, fightingspel och rytmspel är den kritisk: proffs märker även 8 ms fördröjning.

Enligt forskning från NVIDIA (2024) är den genomsnittliga input lag i CS:GO vid 60 FPS utan VSync 22 ms, och med VSync — 39 ms. Vid 144 FPS minskar skillnaden till 14 vs 18 ms respektive. På mobila plattformar är input lag från VSync mindre kritisk på grund av touchinmatning, där touchskärmens hårdvarufördröjning (10–30 ms) maskerar den extra synkroniseringsfördröjningen.

Konfiguration av VSync i mobil utveckling

I mobil utveckling hanteras VSync via grafiska API:er, spelmotorer och systeminställningar i OS. iOS ger mindre kontroll, Android — mer via Vulkan och OpenGL ES. Valet av läge beror på applikationstyp: spel, UI eller video.

VSync i Unity och Unreal Engine

Unity använder inställningen QualitySettings.vSyncCount: 0 — avstängd, 1 — VSync vid varje VBlank, 2 — vid varannan (FPS halveras). I Unreal Engine hanteras VSync via konsolkommandot r.VSync och DefaultEngine.ini. För mobila byggen rekommenderas att stänga av VSync i Unity och använda en egen FPS-begränsare, eftersom inbyggd VSync i Android SurfaceFlinger kan skapa oförutsägbara fördröjningar.

// Unity — hantering av VSync och FPS
void Awake()
{
    // 0 = VSync avaktiverad, 1 = VSync aktiverad
    QualitySettings.vSyncCount = 0;
    // Egen FPS-begränsare istället för VSync
    Application.targetFrameRate = 60;
}

VSync i Vulkan och Metal

Vulkan ger full kontroll via VkSwapchainPresentInfo och presentMode: VK_PRESENT_MODE_FIFO_KHR — klassisk VSync, VK_PRESENT_MODE_MAILBOX_KHR — trippelbuffring utan väntan, VK_PRESENT_MODE_IMMEDIATE_KHR — utan synkronisering. Metal i iOS hanterar VSync via CAMetalLayer.displaySyncEnabled. Från och med iOS 14 rekommenderar Apple att använda displaySyncEnabled = true som standard för alla applikationer utom spel med arkadstyrning.

FPS-begränsning utan VSync

FPS-begränsare — ett alternativ till VSync där applikationen programmatiskt begränsar bildfrekvensen, utan att vänta på VBlank. Detta tillvägagångssätt ger förutsägbar fördröjning och är inte beroende av displayens uppdateringsfrekvens. På Android implementeras FPS-begränsning via Choreographer, på iOS — via CADisplayLink med manuell kontroll av utmatningstiden.

VSync och moderna synkroniseringstekniker

Traditionell VSync har en grundläggande nackdel: den är bunden till en fast uppdateringsfrekvens på displayen. Om GPU producerar 45 FPS på en 60 Hz-skärm kan VSync inte visa 45 bilder — den visar 30 (hoppar över varannan VBlank) eller växlar mellan 60 och 30 med ojämna intervall. Detta skapar hackande (stutter), vilket förstör spelupplevelsen mer än tearing.

Adaptive Sync (FreeSync, G-Sync, Apple ProMotion) löser detta problem genom att dynamiskt ändra displayens uppdateringsfrekvens i enlighet med applikationens FPS. Om applikationen producerar 47 FPS växlar displayen till 47 Hz — varje bildruta visas exakt en gång, utan rivning och hackande. ProMotion i iOS väljer automatiskt frekvens från 24 till 120 Hz, och balanserar jämnhet och energiförbrukning.

På mobila enheter blir Adaptive Sync standard: iPad Pro (2017+) med ProMotion, Android-flaggskepp med LTPO-displayer (Samsung Galaxy S23 Ultra, Google Pixel 8 Pro) stöder dynamisk uppdateringsfrekvens från 1 till 120 Hz. För utvecklaren innebär detta att VSync i traditionell mening ersätts av systemhantering — det räcker att ställa in targetFrameRate, och OS justerar själv uppdateringsfrekvensen för optimal balans mellan jämnhet och batteritid.