Perché MATLAB è così veloce nella moltiplicazione di matrici?

Sto realizzando alcuni benchmark con CUDA, C ++, C #, Java e utilizzo MATLAB per la verifica e la generazione di matrici. Quando eseguo la moltiplicazione di matrici con MATLAB, 2048x2048anche le matrici più grandi vengono quasi istantaneamente moltiplicate.

             1024x1024   2048x2048   4096x4096
             ---------   ---------   ---------
CUDA C (ms)      43.11      391.05     3407.99
C++ (ms)       6137.10    64369.29   551390.93
C# (ms)       10509.00   300684.00  2527250.00
Java (ms)      9149.90    92562.28   838357.94
MATLAB (ms)      75.01      423.10     3133.90

Solo il CUDA è competitivo, ma ho pensato che almeno il C ++ sarà in qualche modo vicino e non 60 volte più lento. Inoltre non so cosa pensare dei risultati di C #. L'algoritmo è uguale a C ++ e Java, ma c'è un salto 2048da gigante 1024.

In che modo MATLAB sta eseguendo la moltiplicazione delle matrici così velocemente?

Codice C ++:

float temp = 0;
timer.start();
for(int j = 0; j < rozmer; j++)
{
    for (int k = 0; k < rozmer; k++)
    {
        temp = 0;
        for (int m = 0; m < rozmer; m++)
        {
            temp = temp + matice1[j][m] * matice2[m][k];
        }
        matice3[j][k] = temp;
    }
}
timer.stop();

Ecco i miei risultati usando MATLAB R2011a + Parallel Computing Toolbox su una macchina con Tesla C2070:

>> A = rand(1024); gA = gpuArray(A);
% warm up by executing the operations a couple of times, and then:
>> tic, C = A * A; toc
Elapsed time is 0.075396 seconds.
>> tic, gC = gA * gA; toc
Elapsed time is 0.008621 seconds.

MATLAB utilizza librerie altamente ottimizzate per la moltiplicazione di matrici, motivo per cui la semplice moltiplicazione di matrici MATLAB è così veloce. La gpuArrayversione utilizza MAGMA .

Aggiornamento utilizzando R2014a su una macchina con un Tesla K20c, e la nuova timeite gputimeitfunzioni:

>> A = rand(1024); gA = gpuArray(A);
>> timeit(@()A*A)
ans =
    0.0324
>> gputimeit(@()gA*gA)
ans =
    0.0022

Aggiornamento tramite R2018b su una macchina WIN64 con 16 core fisici e Tesla V100:

>> timeit(@()A*A)
ans =
    0.0229
>> gputimeit(@()gA*gA)
ans =
   4.8019e-04

(NB: ad un certo punto (dimentico quando esattamente) è gpuArraypassato da MAGMA a cuBLAS - MAGMA è comunque usato per alcune gpuArrayoperazioni)

Questo tipo di domanda è ricorrente e dovrebbe avere una risposta più chiara di "MATLAB utilizza librerie altamente ottimizzate" o "MATLAB utilizza MKL" per una volta su Stack Overflow.

Storia:

La moltiplicazione di matrici (insieme alla moltiplicazione di matrici, vettori di vettori e molte delle scomposizioni di matrici) è (sono) i problemi più importanti dell'algebra lineare. Gli ingegneri hanno risolto questi problemi con i computer sin dai primi giorni.

Non sono un esperto di storia, ma a quanto pare allora, tutti riscrivevano la sua versione FORTRAN con semplici loop. Poi è arrivata una certa standardizzazione, con l'identificazione di "kernel" (routine di base) che la maggior parte dei problemi di algebra lineare necessitavano per essere risolti. Queste operazioni di base sono state quindi standardizzate in una specifica chiamata: Sottoprogrammi di algebra lineare di base (BLAS). Gli ingegneri potrebbero quindi chiamare queste routine BLAS standard ben collaudate nel loro codice, rendendo il loro lavoro molto più semplice.

BLAS:

BLAS si è evoluto dal livello 1 (la prima versione che ha definito operazioni di vettore scalare e vettoriale-vettoriale) al livello 2 (operazioni di matrice vettoriale) al livello 3 (operazioni di matrice-matrice) e ha fornito sempre più "kernel" così standardizzati più e più delle operazioni fondamentali di algebra lineare. Le implementazioni originali FORTRAN 77 sono ancora disponibili sul sito Web di Netlib .

Verso prestazioni migliori:

Quindi nel corso degli anni (in particolare tra le versioni BLAS livello 1 e livello 2: primi anni '80), l'hardware è cambiato, con l'avvento delle operazioni vettoriali e delle gerarchie di cache. Queste evoluzioni hanno permesso di aumentare sostanzialmente le prestazioni delle subroutine BLAS. Diversi fornitori hanno poi seguito l'implementazione delle routine BLAS, sempre più efficienti.

Non conosco tutte le implementazioni storiche (non ero nato o un bambino allora), ma due dei più importanti sono usciti nei primi anni 2000: Intel MKL e GotoBLAS. Matlab utilizza Intel MKL, che è un ottimo BLAS ottimizzato e che spiega le grandi prestazioni che si vedono.

Dettagli tecnici sulla moltiplicazione Matrix:

Allora perché Matlab (MKL) è così veloce dgemm(moltiplicazione matrice-matrice generale a doppia precisione)? In termini semplici: perché utilizza la vettorializzazione e una buona memorizzazione nella cache dei dati. In termini più complessi: vedi l' articolo fornito da Jonathan Moore.

Fondamentalmente, quando esegui la moltiplicazione nel codice C ++ che hai fornito, non sei affatto favorevole alla cache. Poiché sospetto che tu abbia creato una serie di puntatori per allineare le matrici, i tuoi accessi nel tuo ciclo interno alla colonna k-esima di "matice2": matice2[m][k]sono molto lenti. Infatti, quando accedi matice2[0][k], devi ottenere l'elemento k-esimo dell'array 0 della tua matrice. Quindi nella successiva iterazione, è necessario accedere matice2[1][k], che è l'elemento k-esimo di un altro array (l'array 1). Quindi nella prossima iterazione accedi ad un altro array, e così via ... Dato che l'intera matrice matice2non può stare nella cache più alta (è 8*1024*1024grande byte), il programma deve recuperare l'elemento desiderato dalla memoria principale, perdendo molto tempo.

Se hai appena trasposto la matrice, in modo che gli accessi si trovassero in indirizzi di memoria contigui, il tuo codice sarebbe già in esecuzione molto più velocemente perché ora il compilatore può caricare intere righe nella cache contemporaneamente. Prova questa versione modificata:

timer.start();
float temp = 0;
//transpose matice2
for (int p = 0; p < rozmer; p++)
{
    for (int q = 0; q < rozmer; q++)
    {
        tempmat[p][q] = matice2[q][p];
    }
}
for(int j = 0; j < rozmer; j++)
{
    for (int k = 0; k < rozmer; k++)
    {
        temp = 0;
        for (int m = 0; m < rozmer; m++)
        {
            temp = temp + matice1[j][m] * tempmat[k][m];
        }
        matice3[j][k] = temp;
    }
}
timer.stop();

Quindi puoi vedere come solo la localizzazione della cache ha aumentato in modo sostanziale le prestazioni del tuo codice. Ora le dgemmimplementazioni reali sfruttano questo a un livello molto ampio: eseguono la moltiplicazione su blocchi della matrice definiti dalla dimensione del TLB (Translation lookaside buffer, long story short: che cosa può essere effettivamente memorizzato nella cache), in modo che vengano trasmessi in streaming al processore esattamente la quantità di dati che può elaborare. L'altro aspetto è la vettorializzazione, usano le istruzioni vettorializzate del processore per un throughput ottimale delle istruzioni, cosa che non si può davvero fare dal codice C ++ multipiattaforma.

Infine, le persone che affermano che è a causa dell'algoritmo di Strassen o Coppersmith – Winograd hanno torto, entrambi questi algoritmi non sono implementabili nella pratica, a causa delle considerazioni hardware sopra menzionate.

Questo è il motivo . MATLAB non esegue una moltiplicazione matrice ingenua eseguendo il ciclo su ogni singolo elemento come hai fatto nel tuo codice C ++.

Naturalmente suppongo che tu abbia appena usato C=A*Binvece di scrivere tu stesso una funzione di moltiplicazione.

Matlab ha incorporato LAPACK qualche tempo fa, quindi presumo che la loro moltiplicazione con matrice usi qualcosa almeno così velocemente. Il codice sorgente e la documentazione di LAPACK sono prontamente disponibili.

Puoi anche leggere l'articolo di Anatomy of High-Performance Matrix di Goto e Van De Geijn su http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.140.1785&rep=rep1&type=pdf

La risposta è LAPACK e le librerie BLAS rendono MATLAB incredibilmente veloce nelle operazioni a matrice, non alcun codice proprietario da parte della gente di MATLAB.

Usa le librerie LAPACK e / o BLAS nel tuo codice C ++ per operazioni a matrice e dovresti ottenere prestazioni simili a MATLAB. Queste librerie dovrebbero essere disponibili gratuitamente su qualsiasi sistema moderno e parti sono state sviluppate nel corso di decenni nel mondo accademico. Si noti che esistono più implementazioni, incluse alcune sorgenti chiuse come Intel MKL .

Una discussione su come BLAS ottiene alte prestazioni è disponibile qui.

A proposito, è una vera sofferenza nella mia esperienza chiamare le librerie LAPACK direttamente da c (ma ne vale la pena). Devi leggere la documentazione MOLTO precisamente.

Quando si esegue la moltiplicazione della matrice, si utilizza il metodo di moltiplicazione ingenuo che richiede tempo O(n^3).

Esiste un algoritmo di moltiplicazione di matrici che richiede O(n^2.4). Ciò significa che nel n=2000tuo algoritmo richiede ~ 100 volte più calcoli del miglior algoritmo.
Dovresti davvero controllare la pagina di Wikipedia per la moltiplicazione della matrice per ulteriori informazioni sui modi efficienti per implementarla.

A seconda della tua versione di Matlab, credo che potrebbe già utilizzare la tua GPU.

Un'altra cosa; Matlab tiene traccia di molte proprietà della tua matrice; lega la sua diagonale, erma e così via, e specializza i suoi algoritmi basati su di essa. Forse è specializzato in base alla matrice zero che stai passando, o qualcosa del genere? Forse è la memorizzazione nella cache di ripetute chiamate di funzione, che incasina i tuoi tempi? Forse ottimizza i prodotti a matrice non utilizzati ripetuti?

Per evitare che ciò accada, utilizzare una matrice di numeri casuali e assicurarsi di forzare l'esecuzione stampando il risultato su schermo o disco o altro.

MATLAB utilizza un'implementazione altamente ottimizzata di LAPACK di Intel nota come Intel Math Kernel Library (Intel MKL), in particolare la funzione dgemm . La velocità Questa libreria sfrutta le funzionalità del processore tra cui istruzioni SIMD e processori multi-core. Non documentano quale algoritmo specifico usano. Se dovessi chiamare Intel MKL da C ++ dovresti vedere prestazioni simili.

Non sono sicuro di quale libreria MATLAB usi per la moltiplicazione GPU, ma probabilmente qualcosa come nVidia CUBLAS .

La risposta generale a "Perché Matlab è più veloce nel fare xxx rispetto ad altri programmi" è che Matlab ha molte funzioni integrate e ottimizzate.

Gli altri programmi utilizzati spesso non hanno queste funzioni, quindi le persone applicano le proprie soluzioni creative, sorprendentemente più lente del codice ottimizzato professionalmente.

Questo può essere interpretato in due modi:

1) Il modo comune / teorico: Matlab non è significativamente più veloce, stai solo facendo un benchmark sbagliato

2) Il modo realistico: per queste cose Matlab è più veloce in pratica perché i linguaggi come c ++ sono semplicemente troppo facilmente usati in modi inefficaci.

Il netto contrasto non è solo dovuto alla straordinaria ottimizzazione di Matlab (come già discusso da molte altre risposte), ma anche al modo in cui hai formulato la matrice come oggetto.

Sembra che tu abbia fatto della matrice un elenco di liste? Un elenco di elenchi contiene puntatori a elenchi che contengono quindi gli elementi della matrice. Le posizioni degli elenchi contenuti sono assegnate arbitrariamente. Mentre esegui il ciclo sul tuo primo indice (numero di riga?), Il tempo di accesso alla memoria è molto significativo. In confronto, perché non provi a implementare la matrice come un singolo elenco / vettore usando il seguente metodo?

#include <vector>

struct matrix {
    matrix(int x, int y) : n_row(x), n_col(y), M(x * y) {}
    int n_row;
    int n_col;
    std::vector<double> M;
    double &operator()(int i, int j);
};

E

double &matrix::operator()(int i, int j) {
    return M[n_col * i + j];
}

Lo stesso algoritmo di moltiplicazione dovrebbe essere utilizzato in modo che il numero di flop sia lo stesso. (n ^ 3 per matrici quadrate di dimensione n)

Ti sto chiedendo di cronometrarlo in modo che il risultato sia paragonabile a quello che avevi prima (sulla stessa macchina). Con il confronto, mostrerai esattamente quanto può essere significativo il tempo di accesso alla memoria!

È lento in C ++ perché non stai usando il multithreading. In sostanza, se A = BC, dove sono tutte le matrici, la prima riga di A può essere calcolata indipendentemente dalla seconda riga, ecc. Se A, B e C sono tutte matrici n per n, è possibile accelerare la moltiplicazione per un fattore di n ^ 2, come

a_ {i, j} = sum_ {k} b_ {i, k} c_ {k, j}

Se usi, diciamo, Eigen [ http://eigen.tuxfamily.org/dox/GettingStarted.html ], il multithreading è incorporato e il numero di thread è regolabile.

Perché MATLAB è un linguaggio di programmazione inizialmente sviluppato per l'algebra lineare numerica (manipolazioni di matrici), che ha librerie appositamente sviluppate per le moltiplicazioni di matrici. E ora MATLAB può anche utilizzare le GPU (unità di elaborazione grafica) per questo.

E se esaminiamo i risultati del tuo calcolo:

             1024x1024   2048x2048   4096x4096
             ---------   ---------   ---------
CUDA C (ms)      43.11      391.05     3407.99
C++ (ms)       6137.10    64369.29   551390.93
C# (ms)       10509.00   300684.00  2527250.00
Java (ms)      9149.90    92562.28   838357.94
MATLAB (ms)      75.01      423.10     3133.90

allora possiamo vedere che non solo MATLAB è così veloce nella moltiplicazione di matrici: CUDA C (linguaggio di programmazione di NVIDIA) ha dei risultati migliori di MATLAB. CUDA C ha anche sviluppato librerie appositamente sviluppate per le moltiplicazioni di matrici e utilizza le GPU.

Breve storia di MATLAB

Cleve Moler, il presidente del dipartimento di informatica dell'Università del New Mexico, iniziò a sviluppare MATLAB alla fine degli anni '70. Lo ha progettato per fornire ai suoi studenti l'accesso a LINPACK (una libreria di software per l'esecuzione di algebra lineare numerica) ed EISPACK(è una libreria software per il calcolo numerico dell'algebra lineare) senza che debbano imparare Fortran. Presto si diffuse ad altre università e trovò un pubblico forte all'interno della comunità matematica applicata. Jack Little, un ingegnere, vi fu esposto durante una visita Moler all'Università di Stanford nel 1983. Riconoscendo il suo potenziale commerciale, si unì a Moler e Steve Bangert. Hanno riscritto MATLAB in C e hanno fondato MathWorks nel 1984 per continuare il suo sviluppo. Queste librerie riscritte erano conosciute come JACKPAC. Nel 2000, MATLAB è stato riscritto per utilizzare un nuovo set di librerie per la manipolazione delle matrici, LAPACK (è una libreria software standard per l'algebra lineare numerica).

fonte

Che cos'è CUDA C

CUDA C utilizza anche librerie appositamente sviluppate per le moltiplicazioni di matrici come OpenGL (Open Graphics Library). Utilizza anche GPU e Direct3D (su MS Windows).

La piattaforma CUDA è progettata per funzionare con linguaggi di programmazione come C, C ++ e Fortran. Questa accessibilità rende più semplice per gli specialisti della programmazione parallela l'utilizzo delle risorse della GPU, al contrario delle API precedenti come Direct3D e OpenGL , che richiedevano competenze avanzate nella programmazione grafica. Inoltre, CUDA supporta framework di programmazione come OpenACC e OpenCL .

Esempio di flusso di elaborazione CUDA:

1. Copia i dati dalla memoria principale alla memoria della GPU
2. La CPU avvia il kernel di calcolo della GPU
3. I core CUDA della GPU eseguono il kernel in parallelo
4. Copia i dati risultanti dalla memoria GPU nella memoria principale

Confronto tra velocità di esecuzione di CPU e GPU

Abbiamo eseguito un benchmark in cui abbiamo misurato il tempo necessario per eseguire 50 intervalli di tempo per dimensioni di griglia di 64, 128, 512, 1024 e 2048 su un processore Intel Xeon X5650 e quindi utilizzando una GPU NVIDIA Tesla C2050.

Per una dimensione della griglia di 2048, l'algoritmo mostra una riduzione di 7,5 volte del tempo di calcolo da più di un minuto sulla CPU a meno di 10 secondi sulla GPU. Il diagramma della scala del registro mostra che la CPU è effettivamente più veloce per le dimensioni di griglia di piccole dimensioni. Man mano che la tecnologia evolve e matura, tuttavia, le soluzioni GPU sono sempre più in grado di gestire piccoli problemi, una tendenza che prevediamo di continuare.

fonte

Dall'introduzione per la Guida alla programmazione CUDA C:

Spinta dall'insaziabile richiesta del mercato per la grafica 3D ad alta definizione in tempo reale, la Graphic Processor Unit o GPU programmabile si è evoluta in un processore altamente parallelo, multithread, molti core con un'enorme potenza computazionale e una larghezza di banda di memoria molto elevata, come illustrato da Figure 1e Figure 2.

Figura 1. Operazioni in virgola mobile al secondo per CPU e GPU

Figura 2 . Larghezza di banda di memoria per CPU e GPU

Il motivo alla base della discrepanza nella capacità in virgola mobile tra la CPU e la GPU è che la GPU è specializzata per calcoli ad alta intensità di calcolo, altamente paralleli - esattamente ciò che riguarda il rendering grafico - e quindi progettata in modo tale che più transistor siano dedicati all'elaborazione dei dati piuttosto che memorizzazione nella cache dei dati e controllo del flusso, come schematicamente illustrato da Figure 3.

Figura 3 . La GPU dedica più transistor all'elaborazione dei dati

Più specificamente, la GPU è particolarmente adatta per affrontare i problemi che possono essere espressi come calcoli paralleli ai dati - lo stesso programma viene eseguito su molti elementi di dati in parallelo - con elevata intensità aritmetica - il rapporto tra operazioni aritmetiche e operazioni di memoria. Poiché lo stesso programma viene eseguito per ogni elemento di dati, vi è un requisito inferiore per un controllo di flusso sofisticato e poiché viene eseguito su molti elementi di dati e ha un'intensità aritmetica elevata, la latenza dell'accesso alla memoria può essere nascosta con calcoli anziché cache di big data .

L'elaborazione parallela dei dati associa gli elementi di dati ai thread di elaborazione paralleli. Molte applicazioni che elaborano set di dati di grandi dimensioni possono utilizzare un modello di programmazione parallelo ai dati per accelerare i calcoli. Nel rendering 3D, grandi set di pixel e vertici sono mappati su thread paralleli. Allo stesso modo, le applicazioni di elaborazione di immagini e supporti come la post-elaborazione di immagini renderizzate, la codifica e decodifica video, il ridimensionamento delle immagini, la visione stereo e il riconoscimento di modelli possono mappare blocchi di immagini e pixel su thread di elaborazione paralleli. In effetti, molti algoritmi al di fuori del campo del rendering e dell'elaborazione delle immagini sono accelerati dall'elaborazione parallela dei dati, dall'elaborazione generale del segnale o dalla simulazione fisica alla finanza computazionale o alla biologia computazionale.

fonte

Lettura avanzata

• GPU (unità di elaborazione grafica)
• MATLAB
• Guida alla programmazione CUDA C.
• Utilizzo di GPU in MATLAB

• Sottoprogrammi di algebra lineare di base (BLAS)

• Anatomia della moltiplicazione delle matrici ad alte prestazioni , di Kazushige Goto e Robert A. Van De Geijn

Alcuni fac interessanti

Ho scritto la moltiplicazione della matrice C ++ che è veloce come quella di Matlab ma ci è voluto un po 'di attenzione. (Prima Matlab utilizzava GPU per questo).

Esitazione da questa risposta .