Hoe berekent u de processorsnelheid op multicore-processors?

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

De vraag van vandaag &Antwoord sessie komt naar ons met dank aan SuperUser-een onderverdeling 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 vier kernen die elk op 3 GHz draaien, in feite een processor is die draaitop 12 GHz?

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 zedual-processor G4s die elk op 500 MHz werken.

Destijds wist ik dat dit om overspoeld te 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 denkenof hier een echt antwoord op is.

Dit is dus een min of meer filosofische / dieptechnische vraag over de semantiek van 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 binnen een seconde doorloopt, dus zolang alle kernen op dezelfde snelheid draaien, blijft de snelheid van elke klokcyclus hetzelfde, ongeacht het aantal kernenbestaan. Met andere woorden, Hz =( core1Hz + core2Hz +. ..) / kernen.

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

SuperUser-bijdragers Mokubai helpt dingen duidelijk te maken. Hij schrijft:

De hoofdreden 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 werkt, dat wil zeggen single-threaded of multi-threaded. De wet van Amdahl is belangrijk als je kijkt naar de soorten taken die je uitvoert.

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

10: a = a + 1 20: goto 10

Dan is de taak sterk afhankelijk van het resultaatvan de vorige pass en kan niet meerdere kopieën van zichzelf uitvoeren zonder de waarde van 'a' te beschadigen, omdat elk exemplaar op verschillende tijdstippen de waarde van 'a' zou krijgen en het anders zou schrijven. Dit beperkt de taak tot een enkele thread en dus kan de taak alleen ooit op een enkele kern worden uitgevoerd, als deze op meerdere kernen zou worden uitgevoerd, dan zou de synchronisatiecorruptie plaatsvinden. Dit beperkt het tot 1/2 van de CPU-kracht van een dual-core systeem, 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: goto 10

Al deze lijnen zijn onafhankelijk en zouden kunnenworden opgesplitst in 4 afzonderlijke programma's zoals de eerste en tegelijkertijd worden uitgevoerd, waarbij elk in staat is effectief gebruik te maken van de volledige kracht van een van de kernen zonder synchronisatieproblemen, dit is waar de wet van Amdah in komt.

Dus als je een applicatie met enkelvoudige threads hebt die brute force-berekeningen uitvoert, wint de enkele 12GHz-processor zonder meer, als je de taak op de een of andere manier kunt splitsen in afzonderlijke delen en multi-threaded, dan kunnen de 4 kernen in de buurt komen, maar niet helemaal reiken, dezelfde uitvoering, als bij 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 ze hun werk snel en efficiënt doen.

Het argument van "6 cores x 0.2GHz = 1,2 Ghz" 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 heel 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 voltooid.

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

Elke kern kan x berekeningen per seconde uitvoeren, 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 lopen, blijft de snelheid van elke klokcyclus hetzelfde, ongeacht het aantal kernenbestaan. Met andere woorden, Hz =( core1Hz + core2Hz +. ..) / kernen.

Ik denk dat het een misvatting is om te denken dat 4 x 3GHz = 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 veranderen in 4 x 3GHz = 4 x 3GHz.

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