MKL Tweak auf Ryzen Systemen verbessert die Leistung drastisch

Iscaran · 3. September 2020

@Ned Flanders : Die Figures sind aber alle MIT dem nun disableten Ryzen Performance MKL Workaround oder?
Interessant wäre ja der Vergleich Mit und Ohne den Trick - nur um mal zu sehen wieviel Performance hier MatLab / bzw. Intel MKL liegen lässt.

Denn das ist das einzige was hier eigentlich zählt um "Druck" aufzubauen was zu ändern. Sei es seitens MatLab (Verwendung von anderen Math-Libs als nur Intel MKL) als auch in der Vermarktungsstrategie und vielleicht auch seitens Intel ihr ekliges Vendor-ID Verhalten wenigstens ÖFFENTLICH zu machen.

Ned Flanders · 4. September 2020

@Iscaran

Die figures sind wie du sagst alle im debug mode gebencht. Wie viel das bei der mkl 2019.2 ausgemacht hat kannst du im Ursprungs Post bei Reddit sehen. Wieviel das bei der aktuellen 2020.2 ausmacht müsste man benchen, kann man aber nicht mit Matlab

Ned Flanders · 24. April 2021

Ich bin über einen der ersten Apple Silicon M1 Benchmarks unter Matlab gestolpert.

Ich hab zum Vergleich mal meinen alten 2600x gegenübergestellt

Matrix size N=2048	6C AMD Ryzen 2600x	8C Apple M1
Test	Calculation time [sec]	Calculation time [sec]
SVD:	0,884091	1,21547
Eigen:	2,670807	3,49856
Cholesky:	0,024629	0,034597
QR:	0,136306	0,145371
100 matrix products:	10,873585	19,050479
Inverse:	0,195866	0,259115
Pseudo-inverse:	1,699905	2,366665

Matrix size N=4096
Test	Calculation time [sec]	Calculation time [sec]
SVD:	9,362006	9,660486
Eigen:	19,267827	19,53395
Cholesky:	0,14654	0,295916
QR:	1,056251	1,118538
100 matrix products:	82,643343	164,244627
Inverse:	1,262526	1,824012
Pseudo-inverse:	15,079661	18,050172
Total Calculation Time	128,818154	214,727701

Apple sitzt offensichtlich im gleichen Nest wie früher AMD. Matlab Anwender mit Mac Affinität sollten da bis auf weiteres meine ich eher zu einer Intel Mac Variante greifen.

süchtla · 24. April 2021

Interessant.

Ich finde, hier sieht man schon recht gut den Stand von ARM im Desktop. Die Architektur ist kleiner und leichter, aber die jahrelangen Optimierungen und HW-Extensions von x86 sind halt nicht einfach so zu knacken. x86 ist halt ein richtig großes Biest mittlerweile, in jeglicher Hinsicht. Power-Efficiency mal außen vor gelassen

Apple hat sich wohl dazu entschieden, mehr in Anwendungen zu optimieren und dafür hardcore-numbercrunching eher zu vernachlässigen. Unter anderem Matrix-Multiplikationen.

Im Vergleich dazu würde ich nun gern einen Bench vom einer CPU des Fujitsu ARM-Supercomputer sehen, ob meine Annahme stimmt oder ARM einfach der "große" Mul-Adder fehlt.

OT: @Ned Flanders Schon alles auf AMD umgerüstet?

knoxxi · 24. April 2021

Und man darf nicht vergessen, wir reden über rund 15 Watt die der M1 benötigt.

Ned Flanders · 15. März 2022

Es gibt mal wieder was neues!

Matlab implementiert mit dem Release von Version 2022a neben der MKL jetzt auch die AMD AOCL Library.

Das wurde gerade heute im offiziellen Matlab Supportforum bekannt gegeben. Dort findet man auch eine How To wie zwischen den beiden Libraries gewechselt werden kann.

https://de.mathworks.com/matlabcent...luded-in-amd-optimizing-cpu-libraries-aocl-wi

Falls einer auf diese Version aktualisiert, ich wäre an ein paar Performance Zahlen im Vergleich natürlich interessiert

Code:

for N=[48, 128, 1024, 2048, 4096]
    if N<100
        N_mult = 1000;
    elseif N<5001
        N_mult = 100;
    else
        N_mult = 10;
    end
    fprintf('N = %d: ', N);
 
    rng(1);
    A = rand(N);
    B = rand(N);
    A_pd = A*A';
 
    tic;
    svd(A);
    t_svd = toc;
    fprintf('SVD ');
 
    tic;
    eig(A);
    t_eig = toc;
    fprintf('Eig ');

    tic;
    chol(A_pd);
    t_chol = toc;
    fprintf('Chol ');
 
    tic;
    qr(A);
    t_qr = toc;
    fprintf('QR ');
 
    tic;
    for k=1:N_mult
        A*B;
    end
    t_mult = toc;
    fprintf('%d mult ', N_mult);
 
    tic;
    inv(A);
    t_inv = toc;
    fprintf('Inv ');
 
    tic;
    pinv(A);
    t_pinv = toc;
    fprintf('Pinv\n\n');
 
    fprintf('TIME IN SECONDS (SIZE: %d):\n', N);
    fprintf('SVD: %f\n', t_svd);
    fprintf('Eigen: %f\n', t_eig);
    fprintf('Cholesky: %f\n', t_chol);
    fprintf('QR: %f\n', t_qr);
    fprintf('%d matrix products: %f\n', N_mult, t_mult);
    fprintf('Inverse: %f\n', t_inv);
    fprintf('Pseudo-inverse: %f\n\n', t_pinv);
end

Ned Flanders · 16. März 2022

Update zum vorherigen Post:

Nach kurzer Rücksprache mit meinem MATLAB Kontakt ist die Situation folgende:

Matlab will/muss mittelfristig auf eine neuere Version der MKL gehen, um neue Features zu unterstützen und so wird Matlab 2022a mit der Intel(R) oneAPI MKL Version 2021.3 ausgeliefert werden. Das war abzusehen. Intel allerdings, hat in der neueren Version dem Debug Mode, welchen Matlab bislang benutzt hat, um AMD Prozessoren vollständig zu unterstützen, den Stecker gezogen.
Dieser Support von AMD CPUs war allerdings der Hauptgrund, warum Matlab bislang auf der letzten MKL mit aktivierbarem Debug Mode geblieben ist. Nur über diesen war es möglich, AMD CPUs vollständig zu unterstützen.

Daher hat Matlab nun mit AMD zusammengearbeitet, um eine Lösung, mit AMDs Optimizing CPU Libraries (AOCL), anbieten zu können, die auch AMD BLIS enthält, AMDs BLAS Version, die Zen Architektur optimiert ist.

After intense collaboration between MathWorks and AMD, as of MATLAB R2022a, MATLAB ships a custom-built version of AOCL 3.1

Benchmarks habe ich bislang keine zur Hand, die Performanceunterschiede zwischen AOCL und MKL sollen aber marginal sein.

Eine sehr lange Story rund um AMD und Intel scheint hier, zumindest was Matlab angeht, jetzt ihr gutes Ende gefunden zu haben und mündet in nativem Support der CPUs beider Hersteller.

Piktogramm · 16. März 2022

@Ned Flanders
Deine Hartnäckigkeit bei dem Thema ist bewundernswert!

Scientist · 16. März 2022

Danke fuer die Infos.

Weil die Berechnungszeit deutlicher schwanken kann, habe ich das Benchmark-Skript um eine Schleife erweitert.
Jede Berechung wird von 1 bis n wiederholt und dabei der Seed von 1 bis n variiert.
Ausgegeben wird dann ein Mittelwert.

Allgemein ist AOCL auf meinem System gleich schnell oder langsamer als MKL.
Operationen zur Zerlegung von Matrizen oder die Berechnung der Inversen dauern deutlich laenger.
Die Pseudoinverse wird min. um den Faktor 10 langsamer berechnet.
Die Rechnenlast wird dabei deutlich schlechter auf die einzelnen Threads verteilt bzw. ueberwiegend wird nur ein Thread ausgelastet.
Da kann man kaum von einer Optimierung reden ...

Matlab 2022a wurde heute frisch installiert.

System:
CPU: Ryzen 5 3600
MB: Asus Prime x370 Pro, Bios-Version: 5606
RAM: 32 GB, 2933 MHz
OS: Windows 10 2004 (19041.1415)

MATLAB Version: 9.11.0.1873467 (R2021b) Update 3
'Intel(R) Math Kernel Library Version 2019.0.3 Product Build 20190125 for Intel(R) 64 architecture applications, CNR branch auto'
'Intel(R) Math Kernel Library Version 2019.0.3 Product Build 20190125 for Intel(R) 64 architecture applications, CNR branch auto, supporting Linear Algebra PACKage (LAPACK 3.7.0)'

N = 48: SVD Eig Chol QR 1000 mult Inv Pinv

TIME IN SECONDS (SIZE: 48):
SVD: 0.000267
Eigen: 0.000590
Cholesky: 0.000069
QR: 0.000150
1000 matrix products: 0.005018
Inverse: 0.000121
Pseudo-inverse: 0.000831

N = 128: SVD Eig Chol QR 100 mult Inv Pinv

TIME IN SECONDS (SIZE: 128):
SVD: 0.000962
Eigen: 0.004616
Cholesky: 0.000075
QR: 0.000253
100 matrix products: 0.003700
Inverse: 0.000386
Pseudo-inverse: 0.002120

N = 1024: SVD Eig Chol QR 100 mult Inv Pinv

TIME IN SECONDS (SIZE: 1024):
SVD: 0.088250
Eigen: 0.536190
Cholesky: 0.003539
QR: 0.014698
100 matrix products: 1.251417
Inverse: 0.027252
Pseudo-inverse: 0.225056

N = 2048: SVD Eig Chol QR 100 mult Inv Pinv

TIME IN SECONDS (SIZE: 2048):
SVD: 0.694035
Eigen: 2.830609
Cholesky: 0.017415
QR: 0.134998
100 matrix products: 7.768689
Inverse: 0.148623
Pseudo-inverse: 1.527480

N = 4096: SVD Eig Chol QR 100 mult Inv Pinv

TIME IN SECONDS (SIZE: 4096):
SVD: 11.707890
Eigen: 21.006213
Cholesky: 0.112871
QR: 0.925456
100 matrix products: 58.535048
Inverse: 0.935221

MATLAB Version: 9.12.0.1884302 (R2022a)
'Intel(R) oneAPI Math Kernel Library Version 2021.3-Product Build 20210611 for Intel(R) 64 architecture applications (CNR branch auto)'
'Intel(R) oneAPI Math Kernel Library Version 2021.3-Product Build 20210611 for Intel(R) 64 architecture applications (CNR branch auto) supporting Linear Algebra PACKage (LAPACK 3.9.0)'

N = 48: SVD Eig Chol QR 1000 mult Inv Pinv

TIME IN SECONDS (SIZE: 48):
SVD: 0.000354
Eigen: 0.000595
Cholesky: 0.000107
QR: 0.000097
1000 matrix products: 0.008703
Inverse: 0.000169
Pseudo-inverse: 0.001824

N = 128: SVD Eig Chol QR 100 mult Inv Pinv

TIME IN SECONDS (SIZE: 128):
SVD: 0.001229
Eigen: 0.005153
Cholesky: 0.000165
QR: 0.000280
100 matrix products: 0.005457
Inverse: 0.000471
Pseudo-inverse: 0.002923

N = 1024: SVD Eig Chol QR 100 mult Inv Pinv

TIME IN SECONDS (SIZE: 1024):
SVD: 0.119803
Eigen: 0.683713
Cholesky: 0.004118
QR: 0.013479
100 matrix products: 1.825575
Inverse: 0.033013
Pseudo-inverse: 0.302689

N = 2048: SVD Eig Chol QR 100 mult Inv Pinv

TIME IN SECONDS (SIZE: 2048):
SVD: 0.882544
Eigen: 2.918988
Cholesky: 0.020611
QR: 0.088443
100 matrix products: 9.714303
Inverse: 0.178889
Pseudo-inverse: 1.801993

N = 4096: SVD Eig Chol QR 100 mult Inv Pinv

TIME IN SECONDS (SIZE: 4096):
SVD: 12.117207
Eigen: 22.622889
Cholesky: 0.132337
QR: 0.554469
100 matrix products: 68.719511
Inverse: 1.353052
Pseudo-inverse: 18.190412

MATLAB Version: 9.12.0.1884302 (R2022a)
'AOCL BLIS 3.1.0'
'AOCL libFLAME 3.1.1, supports LAPACK 3.10.0'

N = 48: SVD Eig Chol QR 1000 mult Inv Pinv

TIME IN SECONDS (SIZE: 48):
SVD: 0.000749
Eigen: 0.000737
Cholesky: 0.000083
QR: 0.000116
1000 matrix products: 0.008716
Inverse: 0.000287
Pseudo-inverse: 0.004487

N = 128: SVD Eig Chol QR 100 mult Inv Pinv

TIME IN SECONDS (SIZE: 128):
SVD: 0.003482
Eigen: 0.006453
Cholesky: 0.000202
QR: 0.000498
100 matrix products: 0.005302
Inverse: 0.001467
Pseudo-inverse: 0.011810

N = 1024: SVD Eig Chol QR 100 mult Inv Pinv

TIME IN SECONDS (SIZE: 1024):
SVD: 0.370502
Eigen: 0.728480
Cholesky: 0.006420
QR: 0.034701
100 matrix products: 1.326828
Inverse: 0.064281
Pseudo-inverse: 3.310767

N = 2048: SVD Eig Chol QR 100 mult Inv Pinv

TIME IN SECONDS (SIZE: 2048):
SVD: 4.929732
Eigen: 3.340040
Cholesky: 0.054681
QR: 0.255645
100 matrix products: 9.965242
Inverse: 0.332732
Pseudo-inverse: 29.776361

N = 4096: SVD Eig Chol QR 100 mult Inv Pinv

TIME IN SECONDS (SIZE: 4096):
SVD: 43.849061
Eigen: 22.694462
Cholesky: 0.282036
QR: 1.616849
100 matrix products: 66.445868
Inverse: 3.102988
Pseudo-inverse: 263.309950

Code:

function t = fcn_benchmark(n)

    if ~exist('n', 'var') || isempty(n)
        n = 1;
    end

    for N = [48, 128, 1024, 2048, 4096]

        fprintf('N = %d: ', N);
        t.svd   = fcnl_svd(n, N);
        t.eig   = fcnl_eig(n, N);
        t.chol  = fcnl_chol(n, N);
        t.qr    = fcnl_qr(n, N);
        [t.mult, N_mult]  = fcnl_N_mult(n, N);
        t.inv   = fcnl_inv(n, N);
        t.pinv  = fcnl_pinv(n, N);
        fprintf('\n\n');
 
        fprintf('TIME IN SECONDS (SIZE: %d):\n', N);
        fprintf('SVD: %f\n', mean(t.svd));
        fprintf('Eigen: %f\n', mean(t.eig));
        fprintf('Cholesky: %f\n', mean(t.chol));
        fprintf('QR: %f\n', mean(t.qr));
        fprintf('%d matrix products: %f\n', N_mult, mean(t.mult));
        fprintf('Inverse: %f\n', mean(t.inv));
        fprintf('Pseudo-inverse: %f\n\n', mean(t.pinv));
    end
end

%% Subfunctions

function [A, B, A_pd] = fcnl_mats(n, N)
    rng(n);
    A = rand(N);
    B = rand(N);
    A_pd = A*A';
end


function t = fcnl_svd(n, N)
    t = nan(n,1);
    for i = 1:n
        [A, ~, ~] = fcnl_mats(n, N);
        tic;
        svd(A);
        t(i) = toc;
    end
    fprintf('SVD ');
end

function t = fcnl_eig(n, N)
    t = nan(n,1);
    for i = 1:n
        [A, ~, ~] = fcnl_mats(n, N);
        tic;
        eig(A);
        t(i) = toc;
    end
    fprintf('Eig ');
end

function t = fcnl_chol(n, N)
    t = nan(n,1);
    for i = 1:n
        [~, ~, A_pd] = fcnl_mats(n, N);
        tic;
        chol(A_pd);
        t(i) = toc;
    end
    fprintf('Chol ');
end

function t = fcnl_qr(n, N)
    t = nan(n,1);
    for i = 1:n
        [A, ~, ~] = fcnl_mats(n, N);
        tic;
        qr(A);
        t(i) = toc;
    end
    fprintf('QR ');
end

function [t, N_mult] = fcnl_N_mult(n, N)
    t = nan(n,1);

    if N<100
        N_mult = 1000;
    elseif N<5001
        N_mult = 100;
    else
        N_mult = 10;
    end

    for i = 1:n
        [A, B, ~] = fcnl_mats(n, N);
        tic;
        for k=1:N_mult
            A*B;
        end
        t(i) = toc;
    end
    fprintf('%d mult ', N_mult);
end

function t = fcnl_inv(n, N)
    t = nan(n,1);
    for i = 1:n
        [A, ~, ~] = fcnl_mats(n, N);
        tic;
        inv(A);
        t(i) = toc;
    end
    fprintf('Inv ');
end

function t = fcnl_pinv(n, N)
    t = nan(n,1);
    for i = 1:n
        [A, ~, ~] = fcnl_mats(n, N);
        tic;
        pinv(A);
        t(i) = toc;
    end
    fprintf('Pinv ');
end

Ned Flanders · 16. März 2022

Piktogramm schrieb:
Deine Hartnäckigkeit bei dem Thema ist bewundernswert!

Ich bin ehrlich gesagt froh darüber, dass der letzte Vorhang zu dem Thema nun gefallen ist. Aber zumindest hat das Ganze einen befriedigenden Ausgang genommen.

Scientist schrieb:
Da kann man kaum von einer Optimierung reden ...

Ja, das sieht eher ernüchternd aus. Sieht so aus als hätten sie sich hauptsächlich um die Matrix Multiplikationen gekümmert. Das scheint auch genau der Punkt zu sein, bei dem die MKL die AMD CPUs noch stiefmütterlich behandelt. Beim Rest scheint sie die AMD CPUs mittlerer Weile ja eigentlich ganz passabel zu bedienen.

Hier mal dein Ergebnis grafisch für eine Matrizengröße von 1024x1024

Auf jedenfall hat AMD es jetzt ja selbst in der Hand sich darum zu kümmern.

Scientist · 16. März 2022

Berechnungszeiten zum Losen eines gut konditionierten linearen Gleichungssystems (Matrixdimension: 2000x30, Anzahl Wiederholungen: 10.000):

	lsqminnorm	pinv	backslash
2021b3-MKL	5,35 s	12,63 s	5,12 s
2022a-MKL	7,62 s	21,38 s	7,65 s
2022b-AOCL	19,10 s	26,19 s	18,29 s

Damit bleibe ich wohl erst mal bei 2021b.

Ned Flanders · 16. März 2022

Yep! Zum Glück kann einem die Version keiner mehr nehmen :-)

Rein interesse halber um mal zu schauen wie sehr sich die MKL auf AMD verbessert hat. Kannst du mal ML 21b3 ohne Umgebungsvariable laufen lassen?

Scientist · 16. März 2022

Was genau meinst du mit "ohne Umgebungsvariable laufen" lassen?

Mit BLAS_VERSION und LAPACK_VERSION als blank?

Code:

set BLAS_VERSION=
set LAPACK_VERSION=

Ned Flanders · 16. März 2022

Scientist schrieb:
Was genau meinst du "ohne Umgebungsvariable laufen" lassen?

Ok, das ist die Version, die die Umgebungsvariable selbst automatisch setzt. Ich hatte das gerade mit der Vorgängerversion verwechselt, bei der man noch händisch MKL_DEBUG_CPU_TYPE=5 als Umgebung setzen musste.

Scientist · 16. März 2022

Ja, genau.
Ohne MKL_DEBUG_CPU_TYPE=5 ist die Performance gleich (Lösen von GLS) oder etwas schlechter gegenueber 2022a-MKL.
An der Matrixmultiplikation hat sich jedoch eine Menge getan.

N = 48: SVD Eig Chol QR 1000 mult Inv Pinv

TIME IN SECONDS (SIZE: 48):
SVD: 0.000269
Eigen: 0.002596
Cholesky: 0.000557
QR: 0.000653
1000 matrix products: 0.010361
Inverse: 0.001421
Pseudo-inverse: 0.000833

N = 128: SVD Eig Chol QR 100 mult Inv Pinv

TIME IN SECONDS (SIZE: 128):
SVD: 0.000999
Eigen: 0.005944
Cholesky: 0.000499
QR: 0.000256
100 matrix products: 0.013642
Inverse: 0.000847
Pseudo-inverse: 0.003096

N = 1024: SVD Eig Chol QR 100 mult Inv Pinv

TIME IN SECONDS (SIZE: 1024):
SVD: 0.146349
Eigen: 0.702449
Cholesky: 0.008340
QR: 0.028473
100 matrix products: 5.115689
Inverse: 0.074526
Pseudo-inverse: 0.450694

N = 2048: SVD Eig Chol QR 100 mult Inv Pinv

TIME IN SECONDS (SIZE: 2048):
SVD: 1.015726
Eigen: 3.674637
Cholesky: 0.067395
QR: 0.274176
100 matrix products: 34.668759
Inverse: 0.504882
Pseudo-inverse: 2.941286

N = 4096: SVD Eig Chol QR 100 mult Inv Pinv

TIME IN SECONDS (SIZE: 4096):
SVD: 12.347641
Eigen: 23.656362
Cholesky: 0.423019
QR: 1.787356
100 matrix products: 262.321335
Inverse: 3.517377
Pseudo-inverse: 26.669780

Ned Flanders · 16. März 2022

Scientist schrieb:
An der Matrixmultiplikation hat sich jedoch eine Menge getan.

Ja, sieht so aus als ob sich bei der MKL mittlererweile in Sachen AMD erheblich was getan hat, wenn man mal die 1024x1024 Werte vergleicht. Deswegen ist die jetzt wohl fit genug für ein Release gewesen und AMD hat dann für die Multiplikation noch die AOCL eingebracht. Mal sehen, wie sich das zukünftig entwickelt.

Danke fürs Testen

süchtla · 16. März 2022

Interessant, danke fürs dran bleiben @Ned Flanders !

Ich bin gespannt, wie sich die Computing-Welt in den nächsten Jahren entwickeln wird.
Wie siehts eigentlich bei spärlich besetzten Matrizen aus? Geht hier noch mehr?

Ned Flanders · 16. März 2022

Kann ich Dir leider nichts zu sagen, ich hab gerade auch kein Matlab zur Hand, um damit zu spielen

süchtla · 16. März 2022

Kein Problem. Ich habe dabei sowieso nicht nur an Matlab gedacht, sondern generell als Frage und mit Hinblick auf FEM-Simulatoren.

MKL Tweak auf Ryzen Systemen verbessert die Leistung drastisch

Captain

Fleet Admiral

Fleet Admiral

Lieutenant

knoxxi

Gast

Fleet Admiral

Fleet Admiral

Admiral

Lt. Commander

Anhänge

Fleet Admiral

Lt. Commander

Fleet Admiral

Lt. Commander

Fleet Admiral

Lt. Commander

Fleet Admiral

Lieutenant

Fleet Admiral

Lieutenant