1. `parfor` en zijn beperkingen begrijpen:

* Wat het is: Met `parfor` (Parallel For Loop) kunt u iteraties van een lus parallel uitvoeren over meerdere werkers in een MATLAB-pool (gestart met `parpool`). Dit kan de uitvoeringstijd voor bepaalde typen algoritmen dramatisch verkorten.

* Belangrijke beperkingen: Het begrijpen van de beperkingen van 'parfor' is van cruciaal belang om fouten te voorkomen en correcte parallellisatie te garanderen. De belangrijkste zijn:

* Onafhankelijkheid: Iteraties van de lus *moeten* onafhankelijk van elkaar zijn. Er mogen geen gegevensafhankelijkheden tussen iteraties bestaan. Eén iteratie kan geen gegevens lezen die door een andere iteratie zijn geschreven, of gegevens schrijven die door een andere iteratie zullen worden gelezen. Het overtreden hiervan is een veelvoorkomende bron van bugs.

* Kortingen: Als u resultaten uit meerdere iteraties wilt combineren (bijvoorbeeld waarden optellen), gebruikt u reductievariabelen (zie hieronder).

* Variabele classificatie: `parfor` classificeert variabelen in verschillende typen:

* Loopvariabele: De lusindexvariabele (bijvoorbeeld `i` in `for i =1:n`).

* Loopvariabelen Slice: Een eenvoudige variabele die niet afhankelijk is van de lusvariabele zelf.

* Uitzendvariabele: Een variabele definieerde *vóór* de `parfor`-lus die binnen de lus wordt gelezen maar niet wordt gewijzigd. Dezelfde waarde van de variabele wordt door alle werknemers gebruikt. Het kan een grote matrix of object zijn.

* Reductievariabele: Een variabele die wordt gebruikt om resultaten over iteraties te accumuleren (bijvoorbeeld waarden optellen, een minimum vinden, arrays aaneenschakelen). Vereist een speciale behandeling.

* Tijdelijke/lokale variabelen: Variabelen creëerden *binnen* de `parfor`-lus waarvan de waarden buiten de lus niet nodig zijn. Deze zijn werknemer-privaat.

* Geïndexeerde variabelen: Variabelen zoals `A(i)` of `B{i}` waarvan de afhankelijkheid van `i` afhangt van hoe `A` of `B` worden gebruikt. De automatische classificator van MATLAB moet deze correct classificeren.

* Indexeringsbeperkingen: Het indexeren in arrays binnen de 'parfor'-lus heeft beperkingen om de onafhankelijkheid te garanderen. Veelvoorkomende fouten zijn het proberen vanuit meerdere iteraties naar dezelfde index te schrijven. De array-index moet rechtstreeks afhankelijk zijn van de lusvariabele. Geneste indexering zoals `A(B(i))` kan problemen veroorzaken.

* Functieoproepen: Het aanroepen van externe functies (vooral degene die niet in MATLAB zijn geschreven) binnen 'parfor'-lussen kan serialisatieknelpunten introduceren, waardoor een deel van de prestatiewinst teniet wordt gedaan. Probeer functieaanroepen te vermijden of indien mogelijk de functiecode inline te plaatsen.

* Werkruimtebewustzijn: Elke werknemer heeft zijn eigen werkruimte. Variabelen die binnen de lus zijn gedefinieerd, zijn niet automatisch beschikbaar in de hoofdwerkruimte van MATLAB nadat de lus is voltooid (tenzij het reductievariabelen zijn of worden teruggestuurd via het segment van de lusvariabele).

2. Stappen om te optimaliseren met `parfor`:

1. Identificeer parallelliseerbare secties:

* Zoek naar 'for'-lussen die in elke iteratie onafhankelijke berekeningen uitvoeren. Dit zijn uitstekende kandidaten voor conversie naar 'parfor'.

* Analyseer uw code om te zien of gegevensafhankelijkheden kunnen worden verwijderd of geminimaliseerd. Soms is een kleine reorganisatie van het algoritme nodig om het geschikt te maken voor parallelle uitvoering.

2. Converteer de lus naar `parfor`:

* Vervang `for` door `parfor`:`parfor i =1:n ... end`.

* MATLAB's automatische controle: MATLAB analyseert automatisch de `parfor`-lus op mogelijke problemen. Het zal waarschuwingen of fouten geven als het afhankelijkheden of andere overtredingen van de 'parfor'-regels detecteert. Bekijk deze berichten zorgvuldig.

3. Reductievariabelen verwerken:

* Als u resultaten van iteraties wilt combineren, gebruik dan een reductievariabele. MATLAB biedt ingebouwde ondersteuning voor algemene reductiebewerkingen:

* Samenvatting: `x =x + uitdr;`

* Vermenigvuldigen: `x =x * expr;`

* Aaneenschakeling:

* `x =[x, expr];` (kolomgewijze aaneenschakeling)

* `x =[x; expr];` (rij-gewijze aaneenschakeling)

* Minimum/Maximum:

* `x =min(x, expr);`

* `x =max(x, expr);`

* Logische bewerkingen:

* `x =x &&expr;` (logisch EN)

* `x =x || expr;` (logische OR)

* Aaneenschakeling van celarrays: `x ={x{:}, expr};`

* Voorbeeld:

```matlab

n =1000;

resultaat =0; % Initialiseer *voor* de parfor-lus

parfor i =1:n

resultaat =resultaat + i^2; % Sommatiereductie

einde

disp(resultaat);

```

4. Arrays vooraf toewijzen:

* Als u resultaten naar een array binnen de `parfor`-lus schrijft, wijst u de array *voor* de lus vooraf toe. Dit voorkomt dat MATLAB het formaat van de array herhaaldelijk aanpast, wat een groot prestatieknelpunt kan zijn, vooral parallel.

* Voorbeeld:

```matlab

n =1000;

resultaten =nullen(1, n); % Vooraf toewijzen

parfor i =1:n

resultaten(i) =i^2;

einde

```

5. Gegevensoverdracht minimaliseren:

* Gegevensoverdracht tussen de MATLAB-client en de werknemers kan een aanzienlijke overhead veroorzaken.

* Variabelen uitzenden: Zorg ervoor dat grote invoervariabelen die alleen binnen de lus worden gelezen, op de juiste manier worden geclassificeerd als broadcastvariabelen door ze *vóór* de `parfor`-lus te definiëren.

* Gegevens lokaal houden: Vermijd onnodige gegevenscommunicatie tussen medewerkers en de klant.

6. Vermijd functieaanroepen (indien mogelijk):

* Functieaanroepen binnen een 'parfor'-lus kunnen overhead met zich meebrengen als gevolg van serialisatie en communicatie. Plaats indien mogelijk de code van de functie rechtstreeks in de lus.

* Als u een functie moet gebruiken, zorg er dan voor dat deze is ontworpen voor parallelle uitvoering en dat de communicatie wordt geminimaliseerd.

7. Het aantal werknemers afstemmen:

* Het optimale aantal werknemers hangt af van het specifieke probleem, de hardware (aantal kernen, geheugen) en de overhead van parallellisatie.

* Experimenteer met verschillende aantallen werknemers met behulp van `parpool` om de configuratie te vinden die de beste prestaties oplevert. Het starten van meer werkers dan je CPU-kernen hebt, verbetert over het algemeen *niet* de prestaties, en kan deze zelfs verslechteren als gevolg van contextwisselingsoverhead.

* Gebruik `gcp` om de huidige pool en de grootte ervan te controleren.

8. Profiling:

* Gebruik de profiler van MATLAB (`profile on`, `profile off`, `profile viewer`) om prestatieknelpunten binnen de `parfor`-lus te identificeren. Dit kan u helpen gebieden te identificeren waar verdere optimalisatie nodig is. Kijk specifiek naar de opgeroepen functies en de tijd die wordt besteed aan communicatie of gegevensoverdracht.

Voorbeeld:Monte Carlo-simulatie

Stel dat u de waarde van Pi wilt schatten met behulp van een Monte Carlo-simulatie:

```matlab

n =1e7; % Aantal willekeurige punten

% Seriële versie

tic

binnen_cirkel =0;

voor ik =1:n

x =rand();

y =rand();

als x^2 + y^2 <=1

binnen_cirkel =binnen_cirkel + 1;

einde

einde

pi_schatting_seriaal =4 * binnen_cirkel / n;

tijd_serieel =toc;

% Parallelle versie met parfor

tic

binnen_cirkel_par =0;

parfor i =1:n

x =rand();

y =rand();

als x^2 + y^2 <=1

binnen_circle_par =binnen_circle_par + 1;

einde

einde

pi_schatting_par =4 * binnen_cirkel_par / n;

tijd_parfor =toc;

% Parallelle versie met reductie

tic

parpoolen; % Start de parallelle pool

inside_circle_reduced =0;

parfor i =1:n

x =rand();

y =rand();

als x^2 + y^2 <=1

inside_circle_reduced =inside_circle_reduced + 1; % Reductievariabele

einde

einde

delete(gcp('nocreate')); % sluiten parpool

pi_schatting_reduced =4 * inside_circle_reduced / n;

time_reduced =toc;

disp(['Seriële Pi-schatting:' num2str(pi_schatting_seriële) ' Tijd:' num2str(tijd_seriële)]);

disp(['Parfor Pi-schatting:' num2str(pi_schatting_par) ' Tijd:' num2str(tijd_parfor)]);

disp(['Parfor Reduced Pi Estimate:' num2str(pi_ estimate_reduced) ' Tijd:' num2str(time_reduced)]);

```

Uitleg:

* De seriële versie is een standaard `for`-lus.

* De eerste parallelle versie met parfor zal parallel draaien, maar geeft niet het juiste resultaat. Het probleem is dat `inside_circle_par` door meerdere werkers tegelijk wordt gewijzigd, wat resulteert in verloren updates.

* De tweede parallelle versie met `parfor` en een reductievariabele is de correcte en geoptimaliseerde versie. De reductie `inside_circle_reduced =inside_circle_reduced + 1;` vertelt MATLAB om de resultaten van elke arbeider op de juiste manier te verzamelen zonder raceomstandigheden.

* Een `parpool` wordt geïnitialiseerd voordat `parfor` wordt gebruikt, en daarna afgesloten met `delete(gcp('nocreate'))`. De `('nocreate')` zorgt ervoor dat als er geen pool bestaat, MATLAB niet zal proberen er een te maken (wat tot fouten kan leiden).

Belangrijkste overwegingen en probleemoplossing:

* Dataraces: De meest voorkomende fout zijn dataraces waarbij meerdere iteraties tegelijkertijd naar dezelfde geheugenlocatie proberen te schrijven. MATLAB probeert deze te detecteren, maar soms kunnen ze subtiel zijn.

* Foutopsporing: Het debuggen van 'parfor'-lussen kan een uitdaging zijn. Overweeg eerst een klein aantal iteraties uit te voeren om problemen te isoleren. Gebruik breekpunten strategisch. MATLAB beschikt over een aantal parallelle foutopsporingstools, maar deze zijn vaak minder effectief dan zorgvuldige code-inspectie.

* Overhead: Parallellisatie introduceert overhead (het creëren van werknemers, het overdragen van gegevens). Als de berekening binnen elke iteratie erg klein is, kan de overhead groter zijn dan de voordelen van parallellisatie.

* Hardwarelimieten: Het aantal werknemers moet doorgaans kleiner zijn dan of gelijk zijn aan het aantal fysieke kernen op uw machine.

* MATLAB-versies: Het gedrag van `parfor` en de parallelle computertoolbox kan enigszins variëren tussen MATLAB-versies. Raadpleeg de officiële MATLAB-documentatie voor de specifieke versie die u gebruikt.

Door deze richtlijnen zorgvuldig te volgen en de beperkingen van `parfor` te begrijpen, kunt u het effectief gebruiken om uw MATLAB-programma's te optimaliseren en aanzienlijke prestatieverbeteringen te bereiken voor rekenintensieve taken. Vergeet niet om uw code altijd grondig te testen om de juistheid ervan te garanderen.