Hoe berekent u de processorsnelheid op multikernprocessors?

De komst van economische multi-coreprocessoren van consumentklasse roept bij veel gebruikers de vraag op: hoe bereken je effectief de echte snelheid van een multikernsysteem? Is een 4-core 3Ghz-systeem echt 12 Ghz? Lees verder terwijl we onderzoeken.

De Question & Answer-sessie van vandaag komt tot ons dankzij SuperUser - een onderdeel van Stack Exchange, een community-drive groep van Q & A-websites.

De vraag

SuperUser-lezer NReilingh was benieuwd hoe de processorsnelheid voor een multi-core systeem eigenlijk werd berekend:

Klopt het bijvoorbeeld dat een processor met elk vier kernen met een snelheid van 3 GHz in feite een processor is die op 12 GHz werkt?

Ik kwam ooit in een "Mac versus PC" -argument (dat trouwens NIET de focus is van dit onderwerp ... dat was op de middelbare school) met een kennis die erop stond dat Macs alleen als 1Ghz-machines geadverteerd werden omdat ze dubbel waren -processor G4s die elk op 500 MHz werken.

Op dat moment wist ik dat dit om overspoeld moest worden om redenen waarvan ik denk dat het voor de meeste mensen duidelijk is, maar ik zag net een opmerking op deze website met het effect van "6 cores x 0.2GHz = 1.2Ghz" en dat zette me weer aan het denken over daar is een echt antwoord op.

Dit is dus een min of meer filosofische / dieptechnische vraag over de semantiek van de kloksnelheidberekening. Ik zie twee mogelijkheden:

1. Elke kern doet in feite x berekeningen per seconde, dus het totale aantal berekeningen is x (kernen).
2. De kloksnelheid is eerder een telling van het aantal cycli dat de processor in een seconde doorloopt, dus zolang alle kernen op dezelfde snelheid werken, blijft de snelheid van elke klokcyclus hetzelfde, ongeacht het aantal kernen dat bestaat . Met andere woorden, Hz = (core1Hz + core2Hz + ...) / cores.

Dus wat is de juiste manier om de totale kloksnelheid aan te geven en, nog belangrijker, is het zelfs mogelijk om single-core snelheidsnomenclatuur op een multi-core systeem te gebruiken?

Het antwoord

Bijdragers van SuperUser Mokubai helpen om dingen duidelijk te maken. Hij schrijft:

De belangrijkste reden waarom een ​​quad-core 3GHz-processor nooit zo snel is als een 12 GHz single-core heeft te maken met hoe de taak die op die processor wordt uitgevoerd, dus single-threaded of multi-threaded werkt. De wet van Amdahl is belangrijk als je kijkt naar de soorten taken die je uitvoert.

Als je een taak hebt die inherent lineair is en die je stap voor stap moet uitvoeren, zoals (een heel eenvoudig programma)

10: a = a + 1

20: ga naar 10 

De taak is dan sterk afhankelijk van het resultaat van de vorige pass en kan niet meerdere kopieën van zichzelf uitvoeren zonder de waarde van te beschadigen 'een' aangezien elk exemplaar de waarde zou krijgen van 'een' op verschillende tijdstippen en anders terugschrijven. Dit beperkt de taak tot een enkele thread en dus kan de taak alleen ooit op een enkele core worden uitgevoerd, als deze op meerdere kernen zou worden uitgevoerd, dan zou de synchronisatiecorruptie optreden. Dit beperkt het tot 1/2 van de CPU-kracht van een dual-coresysteem, of 1/4 in een quad-core-systeem.

Neem nu een taak zoals:

10: a = a + 1

20: b = b + 1

30: c = c + 1

40: d = d + 1

50: ga naar 10 

Al deze lijnen zijn onafhankelijk en kunnen worden opgesplitst in 4 afzonderlijke programma's, zoals de eerste en tegelijkertijd worden uitgevoerd, elk kan effectief gebruik maken van de volledige kracht van een van de kernen zonder enig synchronisatieprobleem, dit is waar de wet van Amdahl komt erin.

Dus als je een applicatie met enkelvoudige threads hebt die brute force-berekeningen maakt, zou de enkele 12 GHz-processor zonder meer winnen, als je de taak op de een of andere manier kunt splitsen in afzonderlijke delen en multi-threaded, dan zouden de 4 kernen in de buurt kunnen komen, maar niet helemaal reiken, dezelfde uitvoering, volgens de wet van Amdahl.

Het belangrijkste dat een multi-CPU-systeem u geeft, is reactievermogen. Op een single-core machine die hard werkt, kan het systeem traag lijken omdat het grootste deel van de tijd door één taak kan worden gebruikt en de andere taken slechts in korte bursts tussen de grotere taak worden uitgevoerd, wat resulteert in een systeem dat traag of jaloers lijkt . Op een multi-core systeem krijgt de zware taak één kern en alle andere taken spelen op de andere kernen, waardoor hun werk snel en efficiënt wordt gedaan.

Het argument van "6 cores x 0.2GHz = 1.2Ghz" is onzin in elke situatie behalve waar taken perfect parallel en onafhankelijk zijn. Er zijn een groot aantal taken die zeer parallel lopen, maar ze vereisen nog steeds een of andere vorm van synchronsatie. Handbrake is een video-transducer die zeer goed is in het gebruik van alle beschikbare CPU's, maar er is wel een kernproces voor nodig om de andere threads gevuld te houden met gegevens en de gegevens te verzamelen waarmee ze zijn gedaan.

1. Elke kern doet in feite x berekeningen per seconde, dus het totale aantal berekeningen is x (kernen).

Elke kern is in staat om x berekeningen per seconde uit te voeren, ervan uitgaande dat de werkbelasting evenwijdig is, op een lineair programma dat je alleen maar 1 kern hebt.

1. De kloksnelheid is eerder een telling van het aantal cycli dat de processor in een seconde doorloopt, dus zolang alle kernen op dezelfde snelheid werken, blijft de snelheid van elke klokcyclus hetzelfde, ongeacht het aantal kernen dat bestaat . Met andere woorden, Hz = (core1Hz + core2Hz + ...) / cores.

Ik denk dat het een misvatting is om te denken dat 4 x 3 GHz = 12 GHz, de wiskunde heeft toegestaan, maar je vergelijkt appels met peren en de sommen kloppen gewoon niet, GHz kan niet eenvoudigweg voor elke situatie bij elkaar worden opgeteld. Ik zou het willen veranderen in 4 x 3GHz = 4 x 3GHz.

Heb je iets toe te voegen aan de uitleg? Geluid uit in de reacties. Wilt u meer antwoorden van andere technisch onderlegde Stack Exchange-gebruikers lezen? Bekijk hier de volledige discussiethread.