1. Comprensione di `Parfor` e i suoi vincoli:
* Cos'è: `Parfor` (parallelo per loop) consente di eseguire iterazioni di un ciclo in parallelo su più lavoratori in un pool di matlab (ha iniziato a usare `parpool '). Ciò può ridurre drasticamente i tempi di esecuzione per alcuni tipi di algoritmi.
* Vincoli chiave: Comprendere i vincoli di `Parfor` è fondamentale per evitare errori e garantire una corretta parallelizzazione. Quelli principali sono:
* Indipendenza: Le iterazioni del ciclo * devono * essere indipendenti l'una dall'altra. Non dovrebbero esserci dipendenze di dati tra iterazioni. Un'iterazione non può leggere i dati scritti da un'altra iterazione o di scrivere dati che verranno letti da un'altra iterazione. Violare questo è una fonte comune di bug.
* Riduzioni: Se è necessario combinare i risultati da più iterazioni (ad es. Somming valori), utilizzare le variabili di riduzione (vedi sotto).
* Classificazione variabile: `Parfor` classifica le variabili in diversi tipi:
* Variabile loop: La variabile dell'indice Loop (ad es. `I` in` per i =1:n`).
* Variabili Loop Slice: Una semplice variabile che non ha dipendenza dalla variabile loop stessa.
* Variabile di trasmissione: Una variabile definita * prima * il ciclo `parfor` che viene letto ma non modificato all'interno del ciclo. Lo stesso valore della variabile viene utilizzato da tutti i lavoratori. Può essere una matrice o un oggetto di grandi dimensioni.
* Variabile di riduzione: Una variabile utilizzata per accumulare i risultati attraverso le iterazioni (ad esempio, sommando i valori, trovando array minimi e concatenanti). Richiede una manipolazione speciale.
* Variabili temporanee/locali: Variabili create * All'interno * Il ciclo `Parfor` i cui valori non sono necessari al di fuori del loop. Questi sono privati di lavoratore.
* Variabili indicizzate: Variabili come `A (i)` o `b {i}` la cui dipendenza da `I` dipende da come sono usate` A` o `b`. Il classificatore automatico di Matlab deve classificarli correttamente.
* Restrizioni di indicizzazione: L'indicizzazione in array all'interno del loop `Parfor` ha limitazioni per garantire l'indipendenza. Gli errori comuni prevedono il tentativo di scrivere sullo stesso indice da più iterazioni. L'indice dell'array deve dipendere direttamente dalla variabile loop. L'indicizzazione nidificata come `a (b (i))` può causare problemi.
* Chiamate di funzione: Chiamare le funzioni esterne (in particolare quelle non scritte in MATLAB) all'interno di loop di `Parfor` possono introdurre colli di bottiglia di serializzazione, annullando alcuni dei guadagni delle prestazioni. Cerca di evitare le chiamate di funzione o in linea il codice funzione, se possibile.
* Consapevolezza dell'area di lavoro: Ogni lavoratore ha il proprio spazio di lavoro. Le variabili definite all'interno del ciclo non sono automaticamente disponibili nell'area di lavoro MATLAB principale dopo il completamento del ciclo (a meno che non siano variabili di riduzione o sono passate indietro attraverso la fetta della variabile loop).
2. Passaggi per ottimizzare con `Parfor`:
1. Identifica le sezioni parallelizzabili:
* Cerca `per i loop che eseguono calcoli indipendenti in ogni iterazione. Questi sono candidati principali per la conversione in "Parfor".
* Analizza il codice per vedere se le dipendenze dei dati possono essere rimosse o ridotte al minimo. A volte, è necessaria una leggera riorganizzazione dell'algoritmo per renderlo adatto all'esecuzione parallela.
2. Converti il ciclo in `Parfor`:
* Sostituisci `per` con` parfor`:`parfor i =1:n ... end`.
* Controllo automatico di Matlab: MATLAB analizza automaticamente il ciclo `Parfor` per potenziali problemi. Emetterà avvertimenti o errori se rileva dipendenze o altre violazioni delle regole "Parfor". Rivedere attentamente questi messaggi.
3. Variabili di riduzione della maniglia:
* Se è necessario combinare i risultati dalle iterazioni, utilizzare una variabile di riduzione. MATLAB fornisce supporto integrato per le operazioni di riduzione comuni:
* somma: `x =x + expr;`
* Moltiplicazione: `x =x * expr;`
* Concatenazione:
* `x =[x, expr];` (concatenazione a colonna)
* `x =[x; Expr]; `(concatenazione a righe)
* minimo/massimo:
* `x =min (x, expr);`
* `x =max (x, expr);`
* Operazioni logiche:
* `x =x &&expr;` (logico e)
* `x =x || expr; `(logico o)
* Concatenazione dell'array di celle: `x ={x {:}, expr};`
* Esempio:
`` `Matlab
n =1000;
risultato =0; % Inizializza * prima * il parfring loop
Parfor i =1:n
risultato =risultato + i^2; % Riduzione della somma
FINE
disp (risultato);
`` `
4. Array pre-allocati:
* Se stai scrivendo risultati su un array all'interno del loop `Parfor`, pre-allocare l'array * prima di * il ciclo. Ciò impedisce a Matlab di ridimensionare ripetutamente l'array, che può essere un importante collo di bottiglia delle prestazioni, specialmente in parallelo.
* Esempio:
`` `Matlab
n =1000;
Risultati =zeri (1, n); % Pre-allocare
Parfor i =1:n
risultati (i) =i^2;
FINE
`` `
5. Riduci al minimo il trasferimento dei dati:
* Il trasferimento di dati tra il client MATLAB e i lavoratori può essere un sovraccarico significativo.
* Variabili di trasmissione: Assicurarsi che le grandi variabili di input che vengono lette solo all'interno del loop siano correttamente classificate come variabili di trasmissione definendole * prima * il loop `Parfor`.
* Mantieni i dati locali: Evita la comunicazione non necessaria dei dati tra lavoratori e cliente.
6. Evita le chiamate di funzione (se possibile):
* Le chiamate di funzione all'interno di un loop `Parfor` possono introdurre le spese generali a causa della serializzazione e della comunicazione. Se possibile, inlinea il codice della funzione direttamente nel loop.
* Se è necessario utilizzare una funzione, assicurarsi che sia progettato per l'esecuzione parallela e minimizzi la comunicazione.
7. Sintonizza il numero di lavoratori:
* Il numero ottimale di lavoratori dipende dal problema specifico, dall'hardware (numero di core, memoria) e dal sovraccarico della parallelizzazione.
* Sperimenta con diversi numeri di lavoratori che utilizzano `Parpool` per trovare la configurazione che produce le migliori prestazioni. Iniziare più lavoratori di quanti ne hai i core della CPU generalmente * non * migliora le prestazioni e può persino degradarlo a causa della commutazione del contesto.
* Usa `GCP` per controllare il pool corrente e le sue dimensioni.
8. Profilazione:
* Usa il profiler di Matlab (`profilo On`,` Profile Off`, `Profile Viewer`) per identificare i colli di bottiglia delle prestazioni all'interno del loop` Parfor`. Questo può aiutarti a individuare le aree in cui è necessaria un'ulteriore ottimizzazione. Guarda specificamente le funzioni chiamate e il tempo trascorso in comunicazioni o trasferimenti di dati.
Esempio:simulazione Monte Carlo
Supponiamo che tu voglia stimare il valore di PI usando una simulazione Monte Carlo:
`` `Matlab
n =1e7; % Numero di punti casuali
% Versione seriale
tic
all'interno_circle =0;
per i =1:n
x =rand ();
y =rand ();
Se x^2 + y^2 <=1
all'interno_circle =all'interno_circle + 1;
FINE
FINE
pi_estimate_serial =4 * all'interno_circle / n;
time_serial =TOC;
% Versione parallela con PARFOR
tic
all'interno_circle_par =0;
Parfor i =1:n
x =rand ();
y =rand ();
Se x^2 + y^2 <=1
all'interno_circle_par =all'interno_circle_par + 1;
FINE
FINE
pi_estimate_par =4 * all'interno_circle_par / n;
time_parfor =TOC;
% Versione parallela con riduzione
tic
Parpool; % Inizia la piscina parallela
all'interno_circle_redoced =0;
Parfor i =1:n
x =rand ();
y =rand ();
Se x^2 + y^2 <=1
all'interno_circle_redoced =all'interno_circle_redotto + 1; % Variabile di riduzione
FINE
FINE
delete (gcp ('nocreate')); % Close Parpool
pi_estimate_redoced =4 * all'interno_circle_redoced / n;
time_redoced =TOC;
Disp (['Serial PI stima:' num2str (pi_estimate_serial) tempo:'num2str (time_serial)]);
dist (['parfor pi stima:' num2str (pi_estimate_par) tempo:'num2str (time_parfor)]);
Disp (['parfor ridotto di stima PI:' num2str (pi_estimate_redoced) "tempo:'num2str (time_redoced)]);
`` `
Spiegazione:
* La versione seriale è un loop `per 'standard.
* La prima versione parallela con PARFOR funzionerà in parallelo, ma non darà il risultato corretto. Il problema è che `Inside_circle_par` viene modificato da più lavoratori contemporaneamente, risultando in aggiornamenti persi.
* La seconda versione parallela con `parfor` e una variabile di riduzione è la versione corretta e ottimizzata. La riduzione `all'interno_circle_redoced =all'interno_circle_redotto + 1;` dice a Matlab di accumulare correttamente i risultati di ciascun lavoratore senza condizioni di razza.
* A `parpool` viene inizializzato prima di usare` parfor` e chiuso con `elimina (GCP ('nocreate'))`. `('Nocreate')` Garantisce che se un pool non esiste, Matlab non tenterà di crearne uno (che può portare a errori).
Considerazioni chiave e risoluzione dei problemi:
* Gare di dati: L'errore più comune sono le gare di dati in cui più iterazioni cercano di scrivere contemporaneamente nella stessa posizione di memoria. Matlab tenta di rilevarli, ma a volte possono essere sottili.
* Debug: Il debug di loop `Parfor` può essere impegnativo. Prendi in considerazione la corsa con un piccolo numero di iterazioni per isolare i problemi. Usa i punti di interruzione strategicamente. MATLAB ha alcuni strumenti di debug paralleli, ma sono spesso meno efficaci dell'ispezione attenta del codice.
* Overhead: La parallelizzazione introduce le spese generali (creazione di lavoratori, trasferimento di dati). Se il calcolo all'interno di ciascuna iterazione è molto piccolo, il sovraccarico potrebbe superare i benefici della parallelizzazione.
* Limiti hardware: Il numero di lavoratori dovrebbe essere in genere inferiore o uguale al numero di nuclei fisici sulla macchina.
* Versioni Matlab: Il comportamento di `Parfor` e la casella degli strumenti di elaborazione parallela possono variare leggermente tra le versioni MATLAB. Consultare la documentazione ufficiale MATLAB per la versione specifica che stai utilizzando.
Seguendo attentamente queste linee guida e comprendendo i limiti di "Parfor", è possibile utilizzarlo efficacemente per ottimizzare i programmi MATLAB e ottenere significativi miglioramenti delle prestazioni per compiti intensivi computazionalmente. Ricorda di testare sempre accuratamente il codice per garantire la correttezza.
Programmazione © www.354353.com