"Parfor" -slingan i MATLAB är ett kraftfullt verktyg för att parallellisera beräkningsintensiva uppgifter. Här är en uppdelning av hur man använder det effektivt för optimering:
1. Förstå `parfor` och dess begränsningar:
* vad det är: "Parfor" (parallell för slinga) låter dig köra iterationer av en slinga parallellt över flera arbetare i en MATLAB -pool (började använda "Parpool"). Detta kan dramatiskt minska exekveringstiden för vissa typer av algoritmer.
* Nyckelbegränsningar: Att förstå begränsningarna för "parfor" är avgörande för att undvika fel och säkerställa korrekt parallellisering. De viktigaste är:
* Oberoende: Iterationer av slingan * måste * vara oberoende av varandra. Det bör inte finnas några databeroende mellan iterationer. En iteration kan inte läsa data skrivna av en annan iteration, eller skriva data som kommer att läsas av en annan iteration. Att bryta mot detta är en vanlig källa till buggar.
* minskningar: Om du behöver kombinera resultat från flera iterationer (t.ex. summeringsvärden), använd reduktionsvariabler (se nedan).
* Variabel klassificering: `ParFor` klassificerar variabler i flera typer:
* slingvariabel: Loop -indexvariabeln (t.ex. `i 'i' för i =1:n ').
* Loop Variables Slice: En enkel variabel som inte har något beroende av själva slingvariabeln.
* sändningsvariabel: En variabel definierad * före * den "parfor" -slingan som är läst men inte modifieras i slingan. Samma värde på variabeln används av alla arbetare. Det kan vara en stor matris eller objekt.
* reduktionsvariabel: En variabel som används för att ackumulera resultat över iterationer (t.ex. summera värden, hitta ett minimum, sammankopplat matriser). Kräver särskild hantering.
* Tillfälliga/lokala variabler: Variabler skapade * inuti * den `parfor 'slingan vars värden inte behövs utanför slingan. Dessa är arbetare-privata.
* indexerade variabler: Variabler som `a (i)` eller `b {i}` vars beroende av `i 'beror på hur` a' eller 'b' används. Matlabs automatiska klassificerare måste klassificera dessa korrekt.
* Indexeringsbegränsningar: Indexering till matriser inom "Parfor" -slingan har begränsningar för att garantera oberoende. Vanliga fel innebär att försöka skriva till samma index från flera iterationer. Arrayindexet måste vara direkt beroende av slingvariabeln. Kapslad indexering som `a (b (i))` kan orsaka problem.
* Funktionssamtal: Att ringa externa funktioner (särskilt de som inte är skrivna i MATLAB) inom "Parfor" -slingor kan introducera flaskhalsar i serialiseringen, vilket negerar några av prestandavinsterna. Försök att undvika funktionssamtal eller inline funktionskoden om möjligt.
* Workspace Awareness: Varje arbetare har sin egen arbetsyta. Variabler som definieras i slingan är inte automatiskt tillgängliga i huvudmatlab -arbetsytan efter att slingan har slutförts (såvida de inte är reduktionsvariabler eller passerar tillbaka genom slingvariabelns skiva).
2. Steg för att optimera med `parfor ':
1. Identifiera parallelliserbara sektioner:
* Leta efter `för` slingor som utför oberoende beräkningar i varje iteration. Dessa är främsta kandidater för konvertering till `parfor '.
* Analysera din kod för att se om databeroenden kan tas bort eller minimeras. Ibland behövs en liten omorganisation av algoritmen för att göra den lämplig för parallell exekvering.
2. Konvertera slingan till `parfor`:
* Byt ut `för` med` parfor`:`parfor i =1:n ... slut '.
* Matlabs automatiska kontroll: Matlab analyserar automatiskt "parfor" -slingan för potentiella problem. Det kommer att utfärda varningar eller fel om det upptäcker beroenden eller andra kränkningar av reglerna "Parfor". Granska noggrant dessa meddelanden.
3. Hantera reduktionsvariabler:
* Om du behöver kombinera resultat från iterationer använder du en reduktionsvariabel. MATLAB ger inbyggt stöd för gemensamma reduktionsoperationer:
* summering: `x =x + expr;`
* multiplikation: `x =x * expr;`
* Concatenation:
* `x =[x, expr];` (Kolumnvis sammankoppling)
* `x =[x; expr]; `(radmässigt sammankoppling)
* Minsta/maximalt:
* `x =min (x, expr);`
* `x =max (x, expr);`
* Logiska operationer:
* `x =x &&expr;` (logisk och)
* `x =x || expr; `(logisk eller)
* Cell Array CONCATENATION: `x ={x {:}, expr};`
* Exempel:
`` `Matlab
n =1000;
resultat =0; % Initialiserar * före * parforslingan
parfor i =1:n
resultat =resultat + i^2; % Summeringsminskning
avsluta
disp (resultat);
`` `
4. Fördelningsuppsättningar:
* Om du skriver resultat till en matris inuti "Parfor" -slingan, fördela matrisen * före * slingan. Detta förhindrar att MATLAB upprepade gånger ändrar storleken på matrisen, vilket kan vara en viktig prestandaflaskhals, särskilt parallellt.
* Exempel:
`` `Matlab
n =1000;
resultat =nollor (1, n); % Föreläggande
parfor i =1:n
resultat (i) =i^2;
avsluta
`` `
5. Minimera dataöverföring:
* Dataöverföring mellan MATLAB -klienten och arbetarna kan vara en betydande omkostnad.
* sändningsvariabler: Se till att stora ingångsvariabler som endast läses inuti slingan klassificeras korrekt som sändningsvariabler genom att definiera dem * före * "Parfor" -slingan.
* Håll data lokala: Undvik onödig kommunikation av data mellan arbetare och klienten.
6. Undvik funktionssamtal (om möjligt):
* Funktionssamtal inom en "parfor" -slinga kan introducera omkostnader på grund av serialisering och kommunikation. Om möjligt, inline funktionens kod direkt i slingan.
* Om du måste använda en funktion, se till att den är utformad för parallell exekvering och minimerar kommunikation.
7. Ställ in antalet arbetare:
* Det optimala antalet arbetare beror på det specifika problemet, hårdvaran (antalet kärnor, minne) och överhuvudet för parallellisering.
* Experimentera med olika antal arbetare som använder `Parpool 'för att hitta konfigurationen som ger bästa prestanda. Att starta fler arbetare än du har CPU -kärnor i allmänhet gör * inte * förbättrar prestanda och kan till och med försämra det på grund av kontextbyte över huvudet.
* Använd `GCP` för att kontrollera den aktuella poolen och dess storlek.
8. Profilering:
* Använd Matlabs profiler (`profil på`,` profile off`, `profil viewer ') för att identifiera flaskhalsar i prestanda inom` parfor' slingan. Detta kan hjälpa dig att fastställa områden där ytterligare optimering behövs. Titta specifikt på de funktioner som heter och tiden som spenderas i kommunikation eller dataöverföringar.
Exempel:Monte Carlo Simulation
Låt oss säga att du vill uppskatta värdet på PI med en Monte Carlo -simulering:
`` `Matlab
n =1E7; % Antal slumpmässiga poäng
% Serieversion
tic
Inside_Circle =0;
för i =1:n
x =rand ();
y =rand ();
Om x^2 + y^2 <=1
inuti_circle =inre_circle + 1;
avsluta
avsluta
pi_estimate_serial =4 * inre_circle / n;
TIME_SERIAL =TOC;
% Parallellversion med parfor
tic
inuti_circle_par =0;
parfor i =1:n
x =rand ();
y =rand ();
Om x^2 + y^2 <=1
inuti_circle_par =inre_circle_par + 1;
avsluta
avsluta
pi_estimate_par =4 * inuti_circle_par / n;
TIME_PARFER =TOC;
% Parallell version med reduktion
tic
Parpool; % Starta den parallella poolen
inuti_circle_reduced =0;
parfor i =1:n
x =rand ();
y =rand ();
Om x^2 + y^2 <=1
Inside_Circle_Reduced =Inside_Circle_Reduced + 1; % Reduktionsvariabel
avsluta
avsluta
radera (gcp ('nocreate')); % nära parpool
pi_estimate_reduced =4 * inre_circle_reduced / n;
Time_reduced =TOC;
disp (['seriell pi uppskattning:' num2str (pi_estimate_serial) 'tid:' num2str (time_serial)]);
disp (['parfor pi uppskattning:' num2str (pi_estimate_par) 'tid:' num2str (time_parfor)]);
disp (['parfor reducerad pi uppskattning:' num2str (pi_estimate_reduced) 'tid:' num2str (tid_reducerad)]);
`` `
Förklaring:
* Den seriella versionen är en standard "för" -slinga.
* Den första parallella versionen med Parfor kommer att köras parallellt, men inte ge rätt resultat. Problemet är att "inuti_circle_par" modifieras av flera arbetare på en gång, vilket resulterar i förlorade uppdateringar.
* Den andra parallella versionen med `Parfor 'och en reduktionsvariabel är den korrekta och optimerade versionen. Reduktionen `inre_circle_reduced =inre_circle_reduced + 1;` säger till Matlab att korrekt ackumulera resultaten från varje arbetare utan rasförhållanden.
* En "parpool" initialiseras innan du använder "parfor" och stängs efter med "Delete (gcp (" nocreate "))`. `('Nocreate')` säkerställer att om en pool inte finns, kommer Matlab inte att försöka skapa en (vilket kan leda till fel).
Nyckelöverväganden och felsökning:
* Datasatser: Det vanligaste felet är datastopp där flera iterationer försöker skriva till samma minnesplats samtidigt. Matlab försöker upptäcka dessa, men ibland kan de vara subtila.
* felsökning: Felsökning "parfor" -slingor kan vara utmanande. Överväg att köra med ett litet antal iterationer först för att isolera problem. Använd brytpunkter strategiskt. Matlab har några parallella felsökningsverktyg, men de är ofta mindre effektiva än noggrann kodinspektion.
* overhead: Parallellisering introducerar overhead (skapa arbetare, överföra data). Om beräkningen inom varje iteration är mycket liten, kan omkostnaderna uppväga fördelarna med parallellisering.
* Hårdvarugränser: Antalet arbetare bör vanligtvis vara mindre än eller lika med antalet fysiska kärnor på din maskin.
* Matlab -versioner: Beteendet hos `ParFor 'och den parallella datorverktygslådan kan variera något mellan MATLAB -versionerna. Se den officiella MATLAB -dokumentationen för den specifika versionen du använder.
Genom att noggrant följa dessa riktlinjer och förstå begränsningarna för "parfor" kan du effektivt använda den för att optimera dina MATLAB -program och uppnå betydande prestationsförbättringar för beräkningsintensiva uppgifter. Kom ihåg att alltid testa din kod noggrant för att säkerställa korrekthet.
