Skillnaden mellan stark och svag skalning ligger i hur problemstorleken justeras när antalet processorer ökar och hur detta påverkar den totala effektiviteten för den parallella beräkningen.
Stark skalning:
* Mål: Minska tiden till lösningen för en * fast * problemstorlek genom att öka antalet processorer. Problemet förblir detsamma.
* Scenario: Du har ett specifikt problem som du vill lösa så snabbt som möjligt. Du kastar fler resurser (processorer) på det i hopp om att drastiskt minska exekveringstiden.
* Effektivitet: Stark skalningseffektivitet mäts med hur mycket exekveringstiden minskar när du ökar antalet processorer. Helst skulle fördubblingen av processorerna halvera exekveringstiden. Men detta händer sällan perfekt.
* Formel: `Effektivitet =(speedup) / (antal processorer)`
* `Speedup =(exekveringstid på 1 processor) / (exekveringstid på N -processorer)`
* En effektivitet på 1 (eller 100%) är perfekt stark skalning.
* Begränsningar: Stark skalning har inneboende gränser. När du lägger till fler processorer blir det arbete som varje processor måste göra mindre och mindre. Så småningom överväldigar overheaden för kommunikation, synkronisering och tomgångstid (processorer som väntar på andra) fördelarna med parallellisering. Du når en punkt där att lägga till fler processorer faktiskt * ökar * exekveringstiden. Detta beror på Amdahls lag, som säger att hastigheten för ett program är begränsat av andelen programmet som i sig är sekventiellt (kan inte parallelliseras).
* Påverkan på prestanda:
* positivt (initialt): Minskad exekveringstid för samma problemstorlek.
* negativt (så småningom): Minskande avkastning när kommunikationsomkopplingen dominerar. Kan till och med öka exekveringstiden utöver ett visst antal processorer. Flaskhalsar i delade resurser (t.ex. minnesbuss) blir mer framträdande.
Svag skalning:
* Mål: Håll en * konstant * exekveringstid genom att öka både problemstorleken * och * antalet processorer proportionellt. Varje processor hanterar idealiskt samma mängd arbete.
* Scenario: Du har ett problem du vill lösa på en specifik prestationsnivå, och du vill lösa allt större versioner av det problemet samtidigt som du upprätthåller den prestandan. Du lägger till processorer och ökar problemstorleken i enlighet därmed.
* Effektivitet: Svag skalningseffektivitet mäts med hur väl exekveringstiden förblir konstant när du ökar antalet processorer och problemstorleken. Om exekveringstiden förblir konstant har du perfekt svag skalning.
* Formel: `Effektivitet =(exekveringstid för N -processorer och skalat problem) / (exekveringstid för 1 processor och basproblem)`
* En effektivitet på 1 (eller 100%) indikerar perfekt svag skalning (konstant exekveringstid). Mer praktiskt taget mäter du hur nära 1 effektiviteten förblir när du skalar problemet.
* Fördelar: Svag skalning är ofta lättare att uppnå än stark skalning, särskilt för mycket stora problem. Eftersom mängden arbete per processor förblir relativt konstant, blir kommunikation och synkronisering overhead inte lika dominerande. Det är särskilt användbart för problem där du vill utforska ett större parameterutrymme eller simulera ett större system inom en fast tid.
* Begränsningar: Svag skalning är bara meningsfull om problemet kan skalas på rätt sätt. Vissa problem har inneboende begränsningar av deras storlek eller komplexitet.
* Påverkan på prestanda:
* positivt: Låter dig lösa mycket större problem på rimlig tid utan en betydande ökning av genomförandetiden. Visar skalbarheten för den parallella algoritmen och systemet.
* negativt: Minskar inte tiden för att lösa ett * specifikt * fast problem. Effektiviteten kan försämras när problemet och processorns räkning ökar på grund av kommunikationskostnader så småningom blir betydande.
Sammanfattningsvis:
| Funktion | Stark skalning | Svag skalning |
| ---------------- | -------------------------------------------------------------------------------------------------------------------- |
| Problemstorlek | Fast | Ökar proportionellt med antalet processorer |
| Mål | Minska exekveringstiden för ett fast problem | Håll konstant exekveringstid för skalade problem |
| Fokus | Speedup för en given uppgift | Systemets och algoritmskalbarhet |
| Nyckelfråga | Hur mycket snabbare kan jag lösa det här problemet? | Hur stort problem kan jag lösa under en viss tid? |
| Effektivitet | Minskar när kommunikationskostnaden ökar | Förblir relativt konstant om skalning är effektiv |
| Amdahls lag | Betydande begränsning | Mindre av en begränsning |
Exempel:
* Stark skalning: Simulera vädret för en specifik stad under de kommande 24 timmarna. Du vill få den mest exakta prognosen så snabbt som möjligt. Du ökar antalet processorer för att påskynda beräkningen.
* Svag skalning: Simulera vädret för en region. Du vill simulera vädret över ett större och större geografiskt område samtidigt som du upprätthåller en specifik upplösning och simuleringstid. Du lägger till fler processorer när regionens storlek ökar.
I praktiken är både stark och svag skalning viktiga överväganden vid utformning och utvärdering av parallella algoritmer och system. Valet att fokusera på beror på det specifika problemet och de önskade prestandamålen.
