Matris çarpımında MATLAB neden bu kadar hızlı?

CUDA, C ++, C #, Java ile bazı kıyaslamalar yapıyorum ve doğrulama ve matris üretimi için MATLAB kullanıyorum. MATLAB ile matris çarpımı yaptığımda 2048x2048ve hatta daha büyük matrisler neredeyse anında çoğaltılır.

             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

Sadece CUDA rekabetçi, ama en azından C ++ 'ın biraz yakın olacağını ve 60 kat daha yavaş olmayacağını düşündüm. Ayrıca C # sonuçları hakkında ne düşünmek bilmiyorum. Algoritma C ++ ve Java ile aynıdır, ancak dev bir sıçrama 2048var 1024.

MATLAB matris çarpımını nasıl bu kadar hızlı gerçekleştiriyor?

C ++ Kodu:

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();

Tesla C2070 bulunan bir makinede MATLAB R2011a + Paralel Hesaplama Araç Kutusu kullanarak sonuçlarım :

>> 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, matris çarpımı için yüksek düzeyde optimize edilmiş kütüphaneler kullanır, bu nedenle düz MATLAB matris çarpımı çok hızlıdır. gpuArrayversiyon kullanımları magma .

Tesla K20c'li bir makinede R2014a'yı kullanarak güncelleme ve yeni timeitve gputimeitişlevleri:

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

16 fiziksel çekirdeğe ve Tesla V100'e sahip bir WIN64 makinesinde R2018b kullanarak güncelleme :

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

(Not: bir noktada (tam olarak ne zaman unuttum) gpuArrayMAGMA'dan cuBLAS'a geçildi - MAGMA yine de bazı gpuArrayişlemler için kullanılıyor )

Bu tür bir soru yinelenmektedir ve "MATLAB yüksek düzeyde optimize edilmiş kütüphaneler kullanır" veya "MATLAB, MKL'yi bir kez Yığın Taşması için kullanır.

Tarih:

Matris çarpımı (Matris-vektör, vektör-vektör çarpımı ve birçok matris ayrışması ile birlikte) doğrusal cebirdeki en önemli problemlerdir. Mühendisler bu sorunları bilgisayarlardan beri ilk günlerden beri çözüyorlar.

Tarih konusunda uzman değilim, ama görünüşe göre herkes FORTRAN versiyonunu basit döngülerle yeniden yazdı. Daha sonra bazı doğrusallaştırma, çözülmesi için en doğrusal cebir problemlerinin ihtiyaç duyduğu "çekirdeklerin" (temel rutinler) tanımlanmasıyla ortaya çıktı. Bu temel işlemler daha sonra aşağıdaki temel spesifikasyonda standardize edildi: Temel Lineer Cebir Alt Programları (BLAS). Mühendisler daha sonra kodlarında bu standart, iyi test edilmiş BLAS rutinlerini çağırarak işlerini daha kolay hale getirdiler.

BLAS:

BLAS seviye 1'den (skaler-vektör ve vektör-vektör operasyonlarını tanımlayan ilk versiyon) seviye 2'ye (vektör-matris operasyonları) seviye 3'e (matris-matris operasyonları) dönüştü ve gittikçe daha fazla "çekirdek" sağladı. ve temel lineer cebir işlemlerinden daha fazlası. Orijinal FORTRAN 77 uygulamaları Netlib'in web sitesinde hala mevcuttur .

Daha iyi performansa doğru:

Böylece yıllar boyunca (özellikle BLAS seviye 1 ve seviye 2 sürümleri arasında: 80'lerin başı), donanım vektör işlemlerinin ve önbellek hiyerarşilerinin ortaya çıkmasıyla değişti. Bu gelişmeler BLAS altyordamlarının performansını önemli ölçüde artırmayı mümkün kıldı. Farklı satıcılar daha sonra daha verimli olan BLAS rutinlerini uygulamaya koydu.

Tüm tarihi uygulamaları bilmiyorum (o zamanlar doğmadım veya bir çocuk değilim), ancak en dikkate değer olanlardan ikisi 2000'lerin başında çıktı: Intel MKL ve GotoBLAS. Matlab'ınız çok iyi, optimize edilmiş bir BLAS olan ve gördüğünüz harika performansı açıklayan Intel MKL'yi kullanıyor.

Matris çarpımı ile ilgili teknik detaylar:

Öyleyse Matlab (MKL) neden bu kadar hızlı dgemm(çift duyarlıklı genel matris-matris çarpımı)? Basit bir ifadeyle: çünkü vektörleştirmeyi ve verilerin iyi önbelleğe alınmasını kullanır. Daha karmaşık terimlerle: Jonathan Moore tarafından sağlanan makaleye bakın .

Temel olarak, sağladığınız C ++ kodunda çarpma işlemini gerçekleştirdiğinizde, hiç önbellek dostu olmazsınız. Dizileri sıralamak için bir dizi işaretçi oluşturduğunuzdan şüphelendiğimden, "matice2" nin k-sütununa iç döngünüzdeki erişiminiz matice2[m][k]çok yavaştır. Gerçekten, eriştiğinizde matice2[0][k], matrisinizin 0 dizisinin k-th öğesini almanız gerekir. Sonra bir sonraki yinelemede, matice2[1][k]başka bir dizinin (dizi 1) k-th öğesi olan erişmeniz gerekir . Sonra bir sonraki yinelemede başka bir diziye erişirsiniz, vb ... Tüm matris matice2en yüksek önbelleklere sığmadığından (8*1024*1024 bayt büyüktür), program istenen öğeyi ana bellekten almalı ve çok fazla kaybetmelidir. zaman.

Matrisin yerini değiştirdiyseniz, erişimler bitişik bellek adreslerinde olur, kodunuz çok daha hızlı çalışır çünkü artık derleyici önbellekteki tüm satırları aynı anda yükleyebilir. Bu değiştirilmiş sürümü deneyin:

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();

Böylece, önbellek konumunun kodunuzun performansını nasıl önemli ölçüde artırdığını görebilirsiniz. Şimdi gerçekdgemm uygulamalar bunu çok geniş bir seviyeye kadar kullanıyor: TLB'nin büyüklüğüne göre tanımlanmış matris blokları üzerinde çarpımı gerçekleştiriyorlar (Çeviri lookaside tamponu, uzun öykü kısa: etkili bir şekilde önbelleğe alınabilir), böylece işlemciye akıyorlar tam olarak işleyebileceği veri miktarı. Diğer yönü vektörleştirme, platformlar arası C ++ kodunuzdan gerçekten yapamayacağınız optimum talimat verimi için işlemcinin vektörleştirilmiş talimatlarını kullanır.

Son olarak, bunun Strassen veya Coppersmith-Winograd algoritması nedeniyle yanlış olduğunu iddia eden insanlar, yukarıda belirtilen donanım hususları nedeniyle her iki algoritma da pratikte uygulanamaz.

Bu yüzden . MATLAB, C ++ kodunuzda yaptığınız gibi her bir öğe üzerinde döngü yaparak saf bir matris çarpımı gerçekleştirmez.

Tabii ki, sadece C=A*Bbir çarpım fonksiyonu yazmak yerine kullandığınızı varsayıyorum .

Matlab LAPACK'i bir süre önce dahil etti, bu yüzden matris çarpımının en azından bu kadar hızlı bir şey kullandığını varsayıyorum. LAPACK kaynak kodu ve dokümantasyonu hazır.

Goto ve Van De Geijn'in http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.140.1785&rep=rep1&type=pdf adresindeki "Yüksek Performanslı Matris Çarpımının Anatomisi" adlı makalesine de bakabilirsiniz.

Cevap LAPACK ve BLAS kütüphaneleri , MATLAB'ı matris işlemlerinde kör edici bir şekilde hızlı hale getiriyor, MATLAB'daki insanlar tarafından herhangi bir özel kod değil.

Matris işlemleri için C ++ kodunuzdaki LAPACK ve / veya BLAS kitaplıklarını kullanın ve MATLAB ile benzer performansa sahip olmalısınız. Bu kütüphaneler herhangi bir modern sistemde serbestçe bulunmalı ve parçalar on yıllar boyunca akademide geliştirilmelidir. Intel MKL gibi bazı kapalı kaynaklar da dahil olmak üzere birden çok uygulama olduğunu unutmayın .

BLAS'ın nasıl yüksek performans elde ettiğine dair bir tartışma burada mevcuttur.

BTW, deneyimlerime göre LAPACK kütüphanelerini doğrudan c'den çağırmak (ama buna değer) ciddi bir acı. Belgeleri ÇOK tam olarak okumalısınız.

Matris çarpımı yaparken, zaman alan saf çarpma yöntemini kullanırsınız O(n^3).

Alır matris çarpma algoritması var O(n^2.4). Bu n=2000, algoritmanızda en iyi algoritmanın ~ 100 katı kadar hesaplama gerektirdiği anlamına gelir .
Uygulamanın etkili yolları hakkında daha fazla bilgi için wikipedia sayfasını matris çarpımı açısından kontrol etmelisiniz.

Matlab sürümünüze bağlı olarak, GPU'nuzu zaten kullanıyor olabileceğine inanıyorum.

Başka bir şey; Matlab, matrisinizin birçok özelliğini takip eder; diyagonal, hermetian ve benzerleri olup, algoritmalarını buna dayalı olarak uzmanlaştırır. Belki onu geçmekte olduğunuz sıfır matris üzerine uzmanlaşma, ya da bunun gibi bir şey? Belki zamanlamalarınızı berbat eden tekrarlanan fonksiyon çağrılarını önbelleğe alıyor? Belki de tekrarlanan kullanılmayan matris ürünlerini optimize eder?

Bu tür şeylere karşı korunmak için rasgele sayılardan oluşan bir matris kullanın ve sonucu ekrana veya diske veya başka bir yere yazdırarak yürütmeyi zorladığınızdan emin olun.

MATLAB, Intel'in Intel Math Çekirdek Kütüphanesi (Intel MKL) olarak bilinen Intel'den yüksek düzeyde optimize edilmiş bir uygulama kullanır - özellikle dgemm işlevi . Hız Bu kütüphane, SIMD talimatları ve çok çekirdekli işlemciler dahil olmak üzere işlemci özelliklerinden yararlanır. Hangi algoritmayı kullandıklarını belgelemiyorlar. Intel MKL'yi C ++ 'dan arayacaksanız, benzer bir performans görmelisiniz.

MATLAB'ın GPU çarpımı için hangi kütüphaneyi kullandığından emin değilim ama muhtemelen nVidia CUBLAS gibi bir şey .

"Matlab'ı neden diğer programlardan daha hızlı yapıyor?" Sorusunun genel cevabı, matlab'ın birçok yerleşik, optimize edilmiş fonksiyona sahip olmasıdır.

Sık kullanılan diğer programlar bu işlevlere sahip değildir, bu nedenle insanlar profesyonel olarak optimize edilmiş koddan şaşırtıcı derecede yavaş olan kendi yaratıcı çözümlerini uygularlar.

Bu iki şekilde yorumlanabilir:

1) Ortak / teorik yol: Matlab önemli ölçüde daha hızlı değil, sadece kıyaslamayı yanlış yapıyorsunuz

2) Gerçekçi yol: Bu şeyler için Matlab pratikte daha hızlıdır çünkü c ++ gibi diller etkisiz şekillerde çok kolay kullanılır.

Keskin kontrast sadece Matlab'ın şaşırtıcı optimizasyonundan değil (daha önce başka birçok cevapla tartışıldığı gibi) değil, aynı zamanda matrisi bir nesne olarak formüle ettiğiniz şekildedir.

Matrisi bir liste haline getirdiniz mi? Liste listesi, daha sonra matris öğelerinizi içeren listelere işaretçiler içerir. İçerilen listelerin yerleri isteğe bağlı olarak atanır. İlk dizininiz üzerinde döngü yaparken (satır numarası?), Bellek erişim süresi çok önemlidir. Buna karşılık, aşağıdaki yöntemi kullanarak neden matrisi tek bir liste / vektör olarak denemiyorsunuz?

#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);
};

Ve

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

Flop sayısı aynı olacak şekilde aynı çarpma algoritması kullanılmalıdır. (n boyutunda kare matrisler için n ^ 3)

Sizden bunu zamanlamanızı istiyorum, böylece sonuç daha önce (aynı makinede) olanla karşılaştırılabilir. Karşılaştırma ile tam olarak bellek erişim süresinin ne kadar önemli olabileceğini göstereceksiniz!

Multithreading kullanmadığınız için C ++ 'da yavaş. Esasen, eğer tüm matrisler olan A = BC ise, A'nın ilk satırı 2. sıradan bağımsız olarak hesaplanabilir, vb. A, B ve C'nin hepsi n'den n matrisleri ise, çarpımı hızlandırabilirsiniz. n ^ 2 faktörü,

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

Eigen [ http://eigen.tuxfamily.org/dox/GettingStarted.html ] kullanırsanız, çoklu iş parçacığı yerleşiktir ve iş parçacığı sayısı ayarlanabilir.

Çünkü MATLAB ilk başta özellikle matris çarpmaları için geliştirilmiş kütüphaneleri olan sayısal doğrusal cebir (matris manipülasyonları) için geliştirilmiş bir programlama dilidir. Ve şimdi MATLAB ek olarak GPU'ları da (Grafik işlem birimi) kullanabilir .

Ve hesaplama sonuçlarınıza bakarsak:

             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

matris çarpımında sadece MATLAB'ın o kadar hızlı olmadığını görebiliriz: CUDA C (NVIDIA'dan programlama dili) MATLAB'dan daha iyi sonuçlara sahiptir. CUDA C, özellikle matris çarpımları için geliştirilmiş kütüphanelere sahiptir ve GPU'ları kullanır.

MATLAB'ın kısa tarihi

New Mexico Üniversitesi'nde bilgisayar bilimleri bölümünün başkanı Cleve Moler, 1970'lerin sonunda MATLAB'ı geliştirmeye başladı. Öğrencilerine LINPACK (sayısal doğrusal cebir yapmak için bir yazılım kütüphanesi) ve EISPACK'e erişim sağlamak için tasarladı.(doğrusal cebirin sayısal hesaplanması için bir yazılım kütüphanesidir) Fortran öğrenmek zorunda kalmadan. Yakında diğer üniversitelere yayıldı ve uygulamalı matematik camiasında güçlü bir seyirci buldu. Bir mühendis olan Jack Little, 1983'te Moler'ın Stanford Üniversitesi'ne yaptığı bir ziyaret sırasında ona maruz kaldı. Ticari potansiyelini kabul ederek Moler ve Steve Bangert ile katıldı. MATLAB'ı C'de yeniden yazdılar ve geliştirilmesine devam etmek için 1984'te MathWorks'ü kurdular. Bu yeniden yazılmış kütüphaneler JACKPAC olarak biliniyordu. 2000 yılında, MATLAB matris manipülasyonu için daha yeni bir kütüphane seti kullanmak üzere yeniden yazılmıştır, LAPACK (sayısal doğrusal cebir için standart bir yazılım kütüphanesidir).

Kaynak

CUDA C nedir

CUDA C ayrıca özellikle matris çarpımı için geliştirilmiş kütüphaneleri kullanır. OpenGL (Açık Grafik Kütüphanesi). Ayrıca GPU ve Direct3D kullanır (MS Windows'ta).

CUDA platformu , C, C ++ ve Fortran gibi programlama dilleri ile çalışmak için tasarlanmıştır. Bu erişilebilirlik, grafik programlamada ileri düzey beceriler gerektiren Direct3D ve OpenGL gibi önceki API'ların aksine paralel programlama uzmanlarının GPU kaynaklarını kullanmasını kolaylaştırır . Ayrıca, CUDA OpenACC ve OpenCL gibi programlama çerçevelerini destekler .

CUDA işleme akışı örneği:

1. Ana bellekten GPU belleğine veri kopyalama
2. CPU, GPU hesaplama çekirdeğini başlatır
3. GPU'nun CUDA çekirdekleri çekirdeği paralel olarak yürütür
4. Elde edilen verileri GPU belleğinden ana belleğe kopyalayın

CPU ve GPU Yürütme Hızlarını Karşılaştırma

Intel Xeon İşlemci X5650'de 64, 128, 512, 1024 ve 2048 ızgara boyutları için 50 zaman adımı yürütmek ve ardından bir NVIDIA Tesla C2050 GPU kullanmak için geçen süreyi ölçtüğümüz bir kıyaslama yaptık.

2048 ızgara boyutu için, algoritma işlemcide CPU'da bir dakikadan GPU'da 10 saniyeden daha az bir sürede 7,5 kat azalma gösterir. Günlük ölçeği grafiği, CPU'nun küçük ızgara boyutları için gerçekten daha hızlı olduğunu gösterir. Bununla birlikte, teknoloji geliştikçe ve olgunlaştıkça, GPU çözümleri giderek daha küçük problemlerle başa çıkabiliyor.

Kaynak

CUDA C Programlama Kılavuzu'na girişten:

Tarafından gösterildiği gibi gerçek zamanlı, yüksek çözünürlüklü 3D grafik doymaz pazar talebi ile tahrik, programlanabilir Grafik İşlemcisi Birimi ya da grafik işlemcisi, büyük bir işlem gücü ve yüksek bellek bant genişliği ile son derece paralel okuyuculu, manycore işlemci haline gelmiştir Figure 1ve Figure 2.

Şekil 1. CPU ve GPU için Saniyede Kayan Nokta İşlemleri

Şekil 2 . CPU ve GPU için Bellek Bant Genişliği

CPU ve GPU arasındaki kayan nokta kabiliyetindeki tutarsızlığın arkasındaki neden, GPU'nun yoğun bilgi işlem, yüksek paralel hesaplama - tam olarak grafik oluşturmanın ne olduğu - ve bu nedenle daha fazla transistörün veri işlemeye ayrılacağı şekilde tasarlanmasıdır. veri önbellekleme ve akış kontrolü yerine şematik olarak gösterilmiştir Figure 3.

Şekil 3 . GPU Veri İşlemeye Daha Fazla Transistör Tahsis Ediyor

Daha spesifik olarak, GPU, veri-paralel hesaplamalar olarak ifade edilebilecek problemleri ele almak için özellikle uygundur - aynı program, birçok aritmetik yoğunluğa sahip aritmetik işlemlerin bellek işlemlerine oranı ile paralel olarak birçok veri elemanı üzerinde yürütülür. Her veri öğesi için aynı program yürütüldüğünden, karmaşık akış kontrolü için daha düşük bir gereksinim vardır ve birçok veri öğesinde yürütüldüğünden ve yüksek aritmetik yoğunluğa sahip olduğundan, bellek erişim gecikmesi büyük veri önbellekleri yerine hesaplamalar ile gizlenebilir .

Veri paralel işleme, veri öğelerini paralel işleme dişleriyle eşler. Büyük veri kümelerini işleyen birçok uygulama, hesaplamaları hızlandırmak için veri paralel bir programlama modeli kullanabilir. 3B oluşturmada büyük piksel ve köşe kümeleri paralel iş parçacıklarına eşlenir. Benzer şekilde, oluşturulan görüntülerin sonradan işlenmesi, video kodlama ve kod çözme, görüntü ölçeklendirme, stereo görme ve örüntü tanıma gibi görüntü ve medya işleme uygulamaları, görüntü bloklarını ve pikselleri paralel işleme iş parçacıklarına eşleyebilir. Aslında, görüntü oluşturma ve işleme alanı dışındaki birçok algoritma, genel sinyal işleme veya fizik simülasyonundan hesaplamalı finans veya hesaplama biyolojisine kadar veri paralel işleme ile hızlandırılır.

Kaynak

Gelişmiş okuma

• GPU'lar (Grafik işlem birimi)
• MATLAB
• CUDA C Programlama Kılavuzu
• MATLAB'da GPU'ları kullanma

• Temel Doğrusal Cebir Alt Programları (BLAS)

• Kazushige Goto ve Robert A. Van De Geijn'den Yüksek Performanslı Matris Çarpımının Anatomisi

Bazı ilginç yüzler

Matlab kadar hızlı C ++ matris çarpımı yazdım ama biraz dikkat aldı. (Matlab bunun için GPU kullanmadan önce).

Bu cevaptan alıntı .