Meer kernen betekent niet dat de computer krachtiger is

Het feit dat je een processor kiest met meer kernen vertaalt zich vaak niet in dezelfde mate in een prestatieverbetering bij het gebruik van bepaalde programma's. Waarom doet dit fenomeen zich voor en wat zijn dus de oorzaken ervan? We leggen het je haarfijn uit.

Een van de redenen om in de loop van de tijd nieuwere versies van programma's te gebruiken, is dat ze zijn ontworpen om beter te profiteren van processors met een hoger aantal kernen. Laten we niet vergeten dat met het verstrijken van de tijd het aantal hiervan in de CPU's toeneemt. Maar waarom nemen de prestaties in programma's niet toe?

Meer kernen betekent niet dat de computer krachtiger is

Programma's schalen nooit mee met het aantal kernen

Het is belangrijk om er rekening mee te houden dat de programma's die worden uitgevoerd niet de mogelijkheid hebben om hun actieve processen of taken op een bepaald moment te verdelen, afhankelijk van het aantal uitvoeringsthreads dat we in onze CPU. Vooral vanwege het feit dat deze verdeling expliciet is in de programmacode, dat wil zeggen, het is het product van de vaardigheid van de programmeur en het ontwerp van de applicatie.

Wat eigenlijk relevant is bij het coderen van een programma, is niet om het te optimaliseren om een ​​zo groot mogelijk aantal kernen te gebruiken, maar om latentie. Dit laatste begrijpen als de tijd die een processor nodig heeft om een ​​taak te voltooien, gemeten in tijdseenheden. En het is dat de prestatie van een CPU bestaat uit het voltooien van de meeste taken in de kortst mogelijke tijd. Wat eerst afhangt van uw architectuur en vervolgens van uw kloksnelheid.

Wat ons echter interesseert met betrekking tot latentie, is weten hoeveel taken het in een bepaalde periode kan voltooien, wat de werklast is en dit zal afhangen van de situatie en de manier waarop de programma's zijn geschreven. Met andere woorden, de prestaties zijn niet alleen afhankelijk van de hardware, maar ook van hoe goed of slecht de software is geschreven.

Futuro Procesadores Renderen

Taakverdeling in meerdere kernen

Als we nu het aantal kernen in een systeem vergroten, wordt het mogelijk om het werk in stukken te breken en het veel gemakkelijker af te ronden. Hier komt de T/N-formule om de hoek kijken, waarbij T het aantal uit te voeren taken is en N het aantal uitvoeringsthreads dat het systeem kan uitvoeren. Het is duidelijk dat we het maximale aantal taken op een paar kernen kunnen laden en ze bruut kunnen forceren om ze te repareren. Het probleem is dat deze maatregel contraproductief is omdat het ten goede komt aan de modernste CPU's, die op elke core afzonderlijk betere prestaties leveren.

Multihilo Nucleos

Het verdelen van het werk over verschillende kernen is echter extra werk dat meestal wordt gegeven aan een kern die als dirigent optreedt en de volgende taken moet uitvoeren:

  • Je moet processen en takenlijsten maken en deze te allen tijde goed onder controle hebben.
  • Ze moeten weten hoe ze te allen tijde kunnen voorspellen wanneer een taak begint en eindigt, inclusief de tijd die nodig is om de ene af te ronden en de andere te starten.
  • De verschillende kernels moeten de mogelijkheid hebben om een ​​signaal naar de hoofdkernel te sturen om te weten wanneer een proces begint en eindigt.

Deze oplossing werd overgenomen door SONY, Toshiba en IBM in de Cell Broadband Engine, de centrale processor van de PS3 waar een master core de leiding had over de rest. Hoewel hij veel verder terug was, werd hij geadopteerd door de Atari Jaguar. Voor PS4 heeft SONY dit model niet nog een keer herhaald en niemand heeft het op de pc geïmplementeerd omdat het een nachtmerrie is, maar het is de meest efficiënte manier om het werk te verdelen.

Niet alles kan op meerdere cores draaien

Als we ons afvragen of we elke taak in subtaken kunnen verdelen om voor onbepaalde tijd in een groter aantal kernen te verdelen, is het antwoord nee. Concreet moeten we taken in drie verschillende typen classificeren:

  • Degenen die volledig kunnen worden geparalleliseerd en daarom kunnen worden verdeeld over de verschillende kernen die de centrale processor heeft.
  • Taken die gedeeltelijk parallel kunnen worden uitgevoerd.
  • Delen van de code die niet parallel kunnen worden uitgevoerd.

In het eerste geval wordt T/N toegepast op 100%, in het tweede geval gaan we al de zogenaamde Wet van Amdahl in waarbij de versnelling door het vergroten van het aantal cores partieel is en in het derde geval hebben we simpelweg alle kracht van een enkele kern voor die taak,

Wat onderscheidt de CPU van de GPU in multithreading

Hier komen we op een differentieel punt, elke GPU of grafische chip heeft een besturingseenheid die verantwoordelijk is voor het lezen van de commandolijsten en het verdelen ervan over de verschillende GPU-kernen en zelfs tussen de verschillende eenheden. Dit is een implementatie op hardwareniveau van het vorige geval en werkt perfect in elke configuratie waar je wilt verzadigen, zolang er werk is, en dus zoveel mogelijk kernen bezig wilt houden. We moeten echter begrijpen dat de conceptthread van uitvoering in een GPU altijd overeenkomt met de overeenkomstige gegevens en de bijbehorende lijst met instructies. Dat wil zeggen, een pixel, vertex of andere gegevens.

CPU-GPU

Dat maakt ze gemakkelijk te parallelliseren. Dat wil zeggen, als we een ei zouden willen bakken, zou het proces in de CPU zijn om het ei te bakken, wat volledig sequentieel zou zijn. Aan de andere kant zou het in de grafische chip gewoon een taak zijn om olie te verhitten of een ei in de pan te doen. Dit alles zou het bakken van één ei niet versnellen, maar meerdere, en daarom zijn GPU's beter voor taken zoals het tegelijkertijd berekenen van miljoenen polygonen of pixels, maar niet voor sequentiële taken.