Jellyfin NVIDIA hardware transcoding in Docker instellen

Wat u bouwt

Hardware-transcoding voor Jellyfin op een NVIDIA GPU bestaat uit vier stappen in een vaste volgorde, waarbij alleen de laatste stap binnen Jellyfin plaatsvindt. De container kan geen GPU zien die de host-driver niet heeft geladen. Jellyfin kan geen GPU gebruiken die de container niet kan zien. Werk in deze volgorde; elke fout heeft dan een duidelijke plek om te onderzoeken.

1. Installeer de NVIDIA-driver op de host en bevestig dit met nvidia-smi.
2. Installeer de NVIDIA Container Toolkit zodat Docker een GPU aan een container kan toewijzen.
3. Reserveer de GPU voor de Jellyfin-service in docker-compose.yml en bevestig daarna dat de container deze ziet.
4. Schakel NVENC en NVDEC in de eigen afspeelinstellingen van Jellyfin in en bevestig vervolgens dat een daadwerkelijke stream deze gebruikt.

NVENC (NVIDIA encoder) en NVDEC (NVIDIA decoder) zijn blokken met een vaste functie op de kaart. Dit is aparte hardware ten opzichte van de shader-cores die CUDA (compute unified device architecture) taken uitvoeren. Die scheiding is de reden waarom dit de moeite waard is: een stream die in software meerdere CPU-cores verbruikt, kost nu slechts een klein deel van één core plus een toegewezen hardwareblok op de GPU.

Direct play is altijd beter dan transcoderen, dus controleer dat eerst

Voordat u dit configureert, moet u vaststellen of u transcodeert om een reden die u eenvoudig kunt wegnemen. Jellyfin transcodeert wanneer de client het bestand niet in de huidige vorm kan afspelen. De reden is altijd een van de volgende: de videocodec, de audiocodec, het containerformaat, ondertitels op basis van afbeeldingen of een bitrate-limiet die door de client is opgevraagd.

Open het Dashboard, ga naar Playback en bekijk een actieve sessie terwijl er media wordt afgespeeld. Een sessie met de status Direct playing verstuurt het bestand ongewijzigd en verbruikt vrijwel geen CPU. Een sessie met de status Transcoding toont de reden waarom Jellyfin hiervoor heeft gekozen. Neem die reden weg en de GPU hoeft helemaal niet te worden belast.

Twee wijzigingen elimineren de meeste transcodes. Zet de kwaliteit van de client-app op Auto of op het maximum; een client die om 4 Mbps vraagt, dwingt namelijk een hercodering af van een bestand van 20 Mbps, ongeacht de gebruikte codec. Gebruik daarnaast liever een native client-app dan een browsertabblad, omdat een browser de meest beperkte speler is die u heeft. Een native app op dezelfde tv zal hetzelfde bestand vaak wel direct afspelen.

Ondertitels op basis van afbeeldingen vormen de uitzondering die niet met client-instellingen kan worden opgelost. PGS-ondertitels van een Blu-ray-rip en VOBSUB van een dvd-rip zijn afbeeldingen; deze moeten over de video zelf worden getekend, wat een volledige hercodering van de videostream vereist. Tekstgebaseerde ondertitels in SRT-formaat worden als een apart spoor naar de client gestuurd en kosten niets. Het converteren van ondertitelsporen naar tekst is waar mogelijk waardevoller dan een GPU. De rest van de serverkant wordt behandeld in de handleiding voor het draaien van een Jellyfin-mediaserver op een VPS.

De meeste VPS-abonnementen beschikken niet over een GPU

Standaard VPS-abonnementen bevatten geen GPU. Voer dit commando uit op de server voordat u andere plannen maakt.

lspci -nn | grep -Ei "3d|display|vga"

Op een typische KVM VPS toont dit een virtuele display-adapter van de hypervisor, of helemaal niets bruikbaars. Dat apparaat kan geen video encoderen. Een echte GPU is alleen aanwezig wanneer de provider een fysieke kaart doorgeeft aan uw instantie of een deel daarvan toewijst; dergelijke abonnementen zijn navenant geprijsd. Welke workloads rechtvaardigen de kosten van een GPU VPS beschrijft voor wie dit wel of niet zinvol is.

Als er geen GPU aanwezig is, streef dan naar direct play en beschouw software-transcoding als een uitzondering. Een enkele 1080p H.264 software-transcode is zwaar, maar haalbaar op enkele CPU-cores. Een 4K HDR software-transcode met tone mapping is echter niet iets wat een kleine VPS in real-time kan verwerken; de stream zal haperen terwijl de CPU op 100 procent belasting blijft hangen.

De NVIDIA-driver op de host installeren

Jellyfin 10.11 vereist een minimale NVIDIA-driverversie van 520.56.06 op Linux. Ubuntu levert een hulpprogramma dat automatisch een passend pakket voor u selecteert.

sudo ubuntu-drivers list --gpgpu
sudo ubuntu-drivers install --gpgpu
sudo reboot

--gpgpu selecteert de headless server-variant van de driver; dit is de juiste keuze voor een mediaserver omdat het systeem geen desktopomgeving heeft. Het list-commando toont de beschikbare branches, en u kunt een specifieke branch vastleggen, bijvoorbeeld met sudo ubuntu-drivers install --gpgpu nvidia:570-server. Gebruik een branch die daadwerkelijk in de lijst staat en niet de naam die hier als voorbeeld wordt genoemd.

De server-variant installeert niet altijd automatisch nvidia-smi. Installeer het bijbehorende utils-pakket voor de gekozen branch, bijvoorbeeld met sudo apt install nvidia-utils-570-server. Controleer daarna de driver.

nvidia-smi

Een correct resultaat toont een tabel met de driverversie en CUDA-versie in de koptekst, uw kaart bij naam vermeld en een lege proceslijst. Twee foutmeldingen komen hier vaak voor. nvidia-smi: command not found betekent dat het utils-pakket ontbreekt, niet de driver zelf. NVIDIA-SMI has failed because it couldn't communicate with the NVIDIA driver betekent dat de kernelmodule niet is geladen; bij een nieuwe installatie betekent dit bijna altijd dat u het systeem nog niet opnieuw hebt opgestart, of dat Secure Boot het laden van een niet-ondertekende module blokkeert. Controleer of de module aanwezig is met lsmod | grep nvidia.

De NVIDIA Container Toolkit installeren

De driver stelt de host in staat om de GPU te gebruiken. Docker geeft deze echter niet door aan een container, omdat de container noch de device nodes, noch de driver-libraries bevat. De NVIDIA Container Toolkit is het onderdeel dat beide injecteert bij het starten van de container. Dit zijn de officiële installatiecommando's van NVIDIA voor Debian en Ubuntu.

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
sudo apt-get update
sudo apt-get install -y nvidia-container-toolkit

Het installeren van het pakket is onvoldoende, omdat Docker moet worden geïnformeerd dat de runtime bestaat.

sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

nvidia-ctk runtime configure schrijft een nvidia runtime-vermelding naar /etc/docker/daemon.json. De herstart is de stap die vaak wordt overgeslagen, en het overslaan hiervan veroorzaakt de meest voorkomende fout in deze gehele configuratie. Test de verbinding voordat u Jellyfin aanpast.

sudo docker run --rm --runtime=nvidia --gpus all ubuntu nvidia-smi

Dit zou dezelfde tabel moeten weergeven als de host heeft geprint. Als het proces in plaats daarvan faalt met een foutmelding over het onvermogen om een device driver met gpu-mogelijkheden te selecteren, dan is de nvidia-runtime niet bekend bij de Docker-daemon. Voer in dat geval het configuratiecommando opnieuw uit en herstart de daemon.

Geef de Jellyfin-container toegang tot de GPU in Docker Compose

Dit is de moderne Compose-vorm, die overeenkomt met het voorbeeld dat Jellyfin publiceert.

services:
  jellyfin:
    image: jellyfin/jellyfin
    container_name: jellyfin
    user: 1000:1000
    network_mode: host
    restart: unless-stopped
    environment:
      - NVIDIA_VISIBLE_DEVICES=all
      - NVIDIA_DRIVER_CAPABILITIES=all
    volumes:
      - /srv/jellyfin/config:/config
      - /srv/jellyfin/cache:/cache
      - /srv/media:/media:ro
    runtime: nvidia
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

Start de container en vraag deze direct om informatie.

docker compose up -d
docker compose exec jellyfin nvidia-smi

Als dit de driver-tabel vanuit de container toont, is de GPU correct doorgegeven en is elk resterend probleem een instelling in Jellyfin.

Vier regels in dat bestand vereisen uitleg. capabilities: [gpu] is vereist door Compose zelf; als u deze weglaat, weigert Compose de service in plaats van deze zonder GPU te starten. NVIDIA_DRIVER_CAPABILITIES=all is van belang omdat de toolkit de videobibliotheken alleen in de container mount wanneer de video-capability wordt aangevraagd, en de documentatie van Jellyfin vermeldt deze variabele als vereist voor de officiële image. Zonder deze variabele werkt CUDA wel, maar NVDEC niet, en rapporteert het transcode-logboek Cannot load libnvcuvid.so.1. network_mode: host is wat Jellyfin in het eigen voorbeeld gebruikt, omdat client-auto-discovery op UDP-poort 7359 niet werkt via een bridge-netwerk.

user: 1000:1000 is de laatste, en deze heeft niets met de GPU te maken. Deze bepaalt welke bestanden Jellyfin kan lezen op uw media-mount; een mismatch hier resulteert in een lege bibliotheek in plaats van een rechtenfout. Hoe PUID en PGID een container-gebruiker koppelen aan bestanden op schijf legt de nummering uit, en dit is dezelfde nummering die u al heeft ingesteld als u de Sonarr en Radarr stack in Docker Compose naast deze stack draait.

Waarom de meeste handleidingen nog steeds runtime: nvidia schrijven

De oudere vorm komt voor in bijna elke handleiding die u zult vinden, en deze is niet onjuist. Het is geschiedenis. Het oorspronkelijke nvidia-docker2-pakket registreerde een OCI-runtime genaamd nvidia, dus de enige manier om een GPU in een container te krijgen was --runtime=nvidia plus NVIDIA_VISIBLE_DEVICES. Docker 19.03 voegde de --gpus-vlag en een correcte device-request API toe. Compose had meer tijd nodig om dit bij te benen, en toen dat eenmaal gebeurde, kwam de device request onder deploy.resources.reservations.devices terecht, een sleutel die de meeste mensen hadden geleerd te negeren omdat deploy voorheen Docker Swarm betekende.

Het resultaat is dat beide vormen vandaag de dag werken, en het gepubliceerde voorbeeld van Jellyfin bevat beide tegelijk. Het behouden van runtime: nvidia kost niets en zorgt ervoor dat het bestand werkt op oudere Compose-versies. Als u alleen runtime: nvidia behoudt en het deploy-blok verwijdert, moet u NVIDIA_VISIBLE_DEVICES=all behouden, omdat dat legacy-pad de omgevingsvariabele leest om te bepalen welke apparaten moeten worden geïnjecteerd en geen device request heeft om in plaats daarvan uit te lezen.

NVIDIA hardware-transcodering inschakelen in Jellyfin

Tot nu toe is er nog niets geconfigureerd om Jellyfin de videokaart te laten gebruiken. Ga naar het Dashboard, kies Playback en vervolgens Transcoding. Stel Hardware acceleration in op Nvidia NVENC. Vink Enable hardware encoding aan; als u dit niet doet, decodeert Jellyfin op de GPU en codeert vervolgens op de CPU. Dit is een verwarrende tussenfase waarbij de GPU activiteit vertoont, maar de CPU alsnog zwaar wordt belast.

De optie Enable enhanced NVDEC decoder schakelt tussen het huidige NVDEC-pad en het oudere CUVID-pad. Laat deze ingeschakeld. Voor de verwerking van Dolby Vision is deze optie vereist om NVDEC überhaupt te kunnen gebruiken.

Vink onder Enable hardware decoding for alleen de codecs aan die uw kaart daadwerkelijk kan decoderen. Dit is de instelling waar de meeste fouten worden gemaakt. Het aanvinken van AV1 op een kaart zonder AV1-decoder levert geen foutmelding op. Jellyfin vraagt om een hardwarematige decodering, krijgt deze niet, en valt terug op softwarematige decodering. Het resultaat is een hoge CPU-belasting en een nagenoeg inactieve GPU, wat er precies zo uitziet als wanneer de passthrough niet werkt.

Er geldt nog één beperking voor de gehele pagina: hardware-acceleratie werkt alleen met de meegeleverde jellyfin-ffmpeg-build. Als u het FFmpeg-pad heeft ingesteld op een systeem-FFmpeg, krijgt u slechts gedeeltelijke of helemaal geen versnelling.

Welke codecs uw GPU-generatie kan decoderen en encoderen

Dit zijn de grenzen die Jellyfin documenteert voor NVENC en NVDEC. Decoderen en encoderen zijn afzonderlijke mogelijkheden; een kaart kan de ene ondersteunen zonder de andere.

• H.264 8-bit: elke NVIDIA GPU met NVENC en NVDEC kan dit zowel decoderen als encoderen.
• HEVC 8-bit: decoderen en encoderen vanaf Maxwell tweede generatie (GM206) en nieuwer.
• HEVC 10-bit: decoderen vanaf Maxwell tweede generatie en nieuwer, maar encoderen pas vanaf Pascal en nieuwer.
• AV1: decoderen vanaf Ampere en nieuwer, encoderen vanaf Ada Lovelace en nieuwer.

Het onderscheid bij HEVC 10-bit is in de praktijk vaak het struikelblok. Een kaart uit het Maxwell-tijdperk decodeert uw 4K HDR-bestand op de GPU, maar kan vervolgens geen 10-bit output encoderen, waardoor Jellyfin uitwijkt naar 8-bit H.264. Dat bestand speelt nog steeds af en is voor de meeste clients sowieso de juiste keuze. AV1-encoding is in 2026 zelden wat u wilt, ongeacht uw kaart, omdat de ondersteuning voor AV1-decoding aan de clientzijde nog beperkt is en een transcode juist bedoeld is om een client te bereiken die al moeite had met het bronbestand.

Waarom tone mapping stilletjes de GPU verzadigt

HDR (high dynamic range) naar SDR (standard dynamic range) tone mapping is de instelling die uw GPU-budget verbruikt, en de reden hiervoor is architecturaal. Decode draait op NVDEC. Encode draait op NVENC. Tone mapping draait op geen van beide: het is een CUDA-filter dat wordt uitgevoerd op de shader-cores, hetzelfde general-purpose onderdeel van de GPU dat rekenwerk uitvoert. Een 4K HDR-stream die tone mapping vereist, gebruikt dus zowel de decoder als de encoder, en belast daarbovenop de shaders.

Jellyfin documenteert CUDA tone mapping als beschikbaar op elke NVIDIA GPU die HEVC 10-bit kan decoderen. Dit betekent dat het selectievakje verschijnt en werkt op kaarten die dit bij 4K niet kunnen bijhouden. Het symptoom is een stream die start, buffert en nooit stabiel wordt, terwijl nvidia-smi rapporteert dat de encoder nauwelijks belast is.

Dit is waarom de shader-belasting het waard is om afzonderlijk in de gaten te houden.

nvidia-smi dmon -s u

Dit drukt één regel per seconde af met afzonderlijke kolommen voor sm, enc en dec. Een lage enc- en dec-waarde naast een hoog sm-getal betekent dat de fixed-function blokken niets doen en de shaders de bottleneck vormen; tone mapping, schalen of het inbranden van ondertitels is dan de oorzaak van de belasting. Het CUDA-pad verwerkt ook Dolby Vision profile 5 met zero copy, wat van belang is omdat zonder zero copy de frames tussen filterstappen naar het systeemgeheugen en weer terug reizen, en die heen-en-weer-reis kost bandbreedte bij elk afzonderlijk frame.

Wat de NVENC-sessielimiet voor consumenten daadwerkelijk beperkt

[
  {
    "label": "GeForce RTX 5090",
    "nvenc_engines": 3,
    "max_encode_sessions": 12
  },
  {
    "label": "GeForce RTX 4090",
    "nvenc_engines": 2,
    "max_encode_sessions": 12
  },
  {
    "label": "GeForce RTX 4060",
    "nvenc_engines": 1,
    "max_encode_sessions": 12
  }
]

Dit zijn de gepubliceerde matrixcijfers van NVIDIA per augustus 2026, geen metingen die hier zijn uitgevoerd. Een GeForce-kaart is beperkt tot 12 gelijktijdige encodesessies, ongeacht het model. De limiet bevindt zich in de driver in plaats van in de hardware, en NVIDIA heeft deze in de loop der jaren meermaals verhoogd; raadpleeg daarom de actuele matrix in plaats van een oud forumtopic. Het aantal engines is het onderdeel dat daadwerkelijk verschilt per kaart: de GeForce RTX 5090 beschikt over 3 NVENC-engines, terwijl de GeForce RTX 4060 er 1 heeft. Meer engines betekenen een hogere parallelle encode-doorvoer, niet een hoger maximumaantal sessies.

De limiet telt encodesessies en heeft dus alleen betrekking op transcoding-streams. Direct play en remuxing openen nooit een encodesessie. Datacenterkaarten zoals de L4 staan in dezelfde matrix als onbeperkt vermeld, en een datacenterkaart is doorgaans wat u bij een GPU VPS-abonnement krijgt; de limiet is daarom vooral een aandachtspunt voor thuisservers.

Wanneer u de limiet bereikt, mislukt de transcode en bevat het FFmpeg-logboek OpenEncodeSessionEx failed: out of memory (10). Het bericht verwijst naar het geheugen, maar een weigering vanwege een sessielimiet rapporteert dezelfde code. Controleer daarom het aantal gelijktijdige streams voordat u op zoek gaat naar een VRAM-lek. In de praktijk bereiken de meeste gebruikers de limiet voor tone-mapping of hun uploadbandbreedte ruim voordat zij de twaalfde sessie bereiken.

Controleer of de GPU transcodeert, vertrouw niet op de configuratie

Een opgeslagen instelling is geen bewijs. Speel een bestand af waarvan u weet dat het een transcode afdwingt en voer vervolgens drie controles uit.

1. Open het Dashboard en ga naar Playback. De actieve sessie moet Transcoding vermelden, inclusief de reden. Als er Direct playing staat, wordt er niets getranscodeerd en test u het verkeerde bestand.
2. Open het Dashboard, ga naar Logs en open het nieuwste FFmpeg.Transcode logbestand. Een hardware-transcode toont -hwaccel cuda en -hwaccel_output_format cuda op de opdrachtregel, met h264_nvenc of hevc_nvenc als encoder. Als u daar libx264 ziet staan, betekent dit dat u in software transcodeert, ongeacht wat de instellingenpagina aangeeft.
3. Voer nvidia-smi uit op de host terwijl het afspelen doorgaat. Er moet een proces van /usr/lib/jellyfin-ffmpeg/ffmpeg verschijnen met toegewezen GPU-geheugen, en nvidia-smi dmon -s u moet niet-nul waarden tonen in de kolommen enc en dec.

Voer die derde controle uit op de host, niet in de container. nvidia-smi toont in een container meestal een lege proceslijst omdat deze geen proces-ID's van buiten de eigen namespace kan zien, terwijl de bezettingscijfers wel correct worden weergegeven. Een lege proceslijst in de container is geen fout.

Wanneer het systeem ongemerkt terugvalt op software

Jellyfin geeft de voorkeur aan het voortzetten van het afspelen. Wanneer een hardwarepad niet beschikbaar is, schakelt het over naar software in plaats van de stream te verbreken. De betrouwbare indicator is daarom de CPU-belasting en het FFmpeg-logboek, niet een foutmelding in de interface.

Cannot load libnvcuvid.so.1 in het transcode-logboek betekent dat de decoder-bibliotheek niet in de container is gemount. Stel NVIDIA_DRIVER_CAPABILITIES=all in en maak de container opnieuw aan, omdat een wijziging in de omgevingsvariabelen docker compose up -d vereist om deze opnieuw op te bouwen; een eenvoudige herstart behoudt de oude instellingen.

No capable devices found vanuit h264_nvenc betekent dat FFmpeg de encoder-bibliotheek wel bereikte, maar geen bruikbare kaart vond. Controleer docker compose exec jellyfin nvidia-smi opnieuw, aangezien dit meestal betekent dat de apparaatreservering is verwijderd of dat de container is aangemaakt op basis van een verouderd bestand.

Een hoge CPU-belasting in combinatie met een inactieve GPU betekent dat de decoderingsfase stilletjes faalt. Schakel de codecs uit die uw generatie hardware niet kan decoderen, speel hetzelfde bestand opnieuw af en lees het FFmpeg-logboek om te zien of -hwaccel cuda verschijnt.

Een transcode die start en vervolgens vastloopt bij 4K HDR, terwijl 1080p wel werkt, wijst op de limiet van tone-mapping en niet op een defecte installatie. Bevestig dit via de sm-kolom in nvidia-smi dmon -s u. Verlaag in dat geval de door de client gevraagde resolutie of speel 4K HDR-bestanden alleen af op clients die deze via direct play kunnen verwerken.

FAQ

Waarom gebruikt Jellyfin nog steeds de CPU nadat ik NVENC heb ingeschakeld?

Controleer het nieuwste FFmpeg.Transcode logboek onder Dashboard, en vervolgens Logs. Als hier libx264 staat, werd er geen hardwarepad gebruikt. Dit betekent meestal dat de container de GPU niet kan zien; voer docker compose exec jellyfin nvidia-smi uit om dit te bevestigen. Als er h264_nvenc staat maar de CPU nog steeds zwaar belast wordt, dan draait het decoderingsgedeelte in software. Dit gebeurt wanneer u een codec heeft aangevinkt die uw kaart niet kan decoderen, of wanneer Enable hardware encoding uitgeschakeld bleef, waardoor slechts de helft van de pipeline naar de GPU werd verplaatst.

Heb ik de regel runtime: nvidia nog nodig in Docker Compose?

Niet als u het deploy.resources.reservations.devices blok en een recente versie van Docker Compose heeft. Het blok is de moderne manier om apparaten aan te vragen en voert dezelfde taak uit. runtime: nvidia is de oudere methode uit het nvidia-docker2-tijdperk; dit werkt nog steeds en het officiële voorbeeld van Jellyfin bevat beide. Het behouden van beide kan geen kwaad. Als u alleen runtime: nvidia behoudt, moet u ook NVIDIA_VISIBLE_DEVICES=all behouden, omdat dat pad geen apparaataanvraag bevat om te lezen en de apparatenlijst uit de omgeving haalt.

Hoeveel streams kan één NVIDIA GPU tegelijkertijd transcoderen?

De gepubliceerde matrix van NVIDIA beperkt GeForce-kaarten tot twaalf gelijktijdige encode-sessies per augustus 2026; datacentrumkaarten staan vermeld als onbeperkt. Dat plafond is zelden de beperkende factor. HDR naar SDR tone mapping draait op de shader-cores in plaats van op NVENC, dus een handvol 4K HDR-streams zal de shaders uitputten lang voordat de sessieteller relevant wordt. Meet uw eigen situatie met nvidia-smi dmon -s u en houd de sm-kolom in de gaten, niet het aantal sessies.

Kan ik hardware-transcodering gebruiken op een VPS zonder GPU?

Nee. Voor encodering is het fysieke NVENC-blok vereist, en lspci -nn | grep -Ei "3d|display|vga" op een standaard VPS toont alleen een virtuele display-adapter van de hypervisor. Het realistische antwoord op een abonnement zonder GPU is om de transcodes te elimineren: verhoog de kwaliteitsinstelling van de client naar Auto, gebruik een native client-app in plaats van een browser, en converteer op afbeeldingen gebaseerde ondertiteltracks naar tekst zodat deze geen video-herencodering forceren.

Waarom hapert 4K HDR terwijl 1080p prima transcodeert?

De twee werklasten gebruiken verschillende onderdelen van de kaart. Een 1080p SDR-transcode bestaat enkel uit decoderen en encoderen, beide op hardware met een vaste functie. Een 4K HDR-stream voegt tone mapping toe, wat een CUDA-filter is dat op de shader-cores draait, plus een veel groter frame om te schalen. nvidia-smi dmon -s u dat lage enc- en dec-waarden toont naast een hoge sm-waarde bevestigt dit, omdat dat patroon betekent dat de blokken met vaste functies inactief zijn en de algemene cores de beperkende factor vormen.