Mengapa MATLAB begitu cepat dalam perkalian matriks?


190

Saya membuat beberapa tolok ukur dengan CUDA, C ++, C #, Java, dan menggunakan MATLAB untuk verifikasi dan pembuatan matriks. Ketika saya melakukan perkalian matriks dengan MATLAB, 2048x2048dan bahkan matriks yang lebih besar hampir langsung dikalikan.

             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

Hanya CUDA yang kompetitif, tapi saya pikir setidaknya C ++ akan menjadi agak dekat dan tidak 60 kali lebih lambat. Saya juga tidak tahu harus berpikir apa tentang hasil C #. Algoritma ini adalah sama saja dengan C ++ dan Java, tapi ada lompatan raksasa 2048dari 1024.

Bagaimana MATLAB melakukan perkalian matriks begitu cepat?

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

14
Mungkin ini pertanyaan tentang algoritma yang Anda gunakan.
Robert J.

24
Pastikan Matlab tidak membuat hasil caching Anda, itu adalah binatang yang rumit. Pertama, pastikan perhitungan benar-benar dilakukan, dan kemudian bandingkan.
rubenvb


10
Saya benar-benar berpikir bahwa posting ini benar-benar menarik tetapi saya benar-benar ingin melihat tolok ukur yang lebih tepat. Sebagai contoh, saya berpikir bahwa Matlab R2011a menggunakan multithreading secara otomatis dan perkalian matriks diimplementasikan menggunakan perpustakaan mkl / blas Intel. Jadi, saya akan menebak bahwa c ++ lebih cepat jika seseorang menggunakan panggilan mkl untuk melakukan perkalian matriks. Pertanyaannya kemudian adalah apa overhead Matlab. Saya tahu bahwa ini tergantung pada detail tambahan dari perkalian matriks tetapi angka-angka di atas cukup tidak berarti saat ini.
Lucas

1
Anda dapat menggunakan "Algoritma Strassen" untuk menjalankan waktu O (n ^ 2.81) untuk perkalian matriks persegi besar yang sekitar 10x lebih cepat daripada perkalian asli yang berjalan di O (n ^ 3). SSE / AVX juga dapat membantu Anda mendapatkan sekitar 8-20x lebih cepat untuk eksekusi kode. semua bersama-sama Anda dapat memiliki implementasi ac lebih cepat daripada yang matlab.
DU Jiaen

Jawaban:


85

Inilah hasil saya menggunakan MATLAB R2011a + Parallel Computing Toolbox pada mesin dengan 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 menggunakan pustaka yang sangat dioptimalkan untuk perkalian matriks yang karenanya perkalian matriks MATLAB sangat cepat. The gpuArrayVersi menggunakan magma .

Pembaruan menggunakan R2014a pada mesin dengan Tesla K20c, dan yang baru timeitdan gputimeitberfungsi:

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

Pembaruan menggunakan R2018b pada mesin WIN64 dengan 16 core fisik dan Tesla V100:

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

(NB: di beberapa titik (saya lupa kapan tepatnya) gpuArrayberalih dari MAGMA ke cuBLAS - MAGMA masih digunakan untuk beberapa gpuArrayoperasi sekalipun)


Mengapa ini penting?
Fisikawan Gila

Mengapa yang penting? Saya mencoba memberikan beberapa wawasan tentang perpustakaan yang digunakan oleh MATLAB dalam berbagai situasi untuk menjelaskan mengapa kinerja MATLAB baik - yaitu karena menggunakan perpustakaan numerik yang sangat dioptimalkan.
Edric

175

Pertanyaan semacam ini berulang dan harus dijawab lebih jelas daripada "MATLAB menggunakan perpustakaan yang sangat dioptimalkan" atau "MATLAB menggunakan MKL" untuk sekali di Stack Overflow.

Sejarah:

Perkalian matriks (bersama-sama dengan matriks-vektor, perkalian vektor-vektor dan banyak dari penguraian matriks) adalah masalah yang paling penting dalam aljabar linier. Insinyur telah memecahkan masalah ini dengan komputer sejak awal.

Saya bukan ahli dalam sejarah, tetapi tampaknya saat itu, semua orang hanya menulis ulang versi FORTRAN-nya dengan loop sederhana. Beberapa standardisasi kemudian muncul, dengan identifikasi "kernel" (rutinitas dasar) yang paling dibutuhkan masalah aljabar linier agar dapat dipecahkan. Operasi dasar ini kemudian distandarisasi dalam spesifikasi yang disebut: Basic Linear Aljabar Subprograms (BLAS). Insinyur kemudian dapat memanggil rutin BLAS standar ini yang telah teruji baik dalam kode mereka, membuat pekerjaan mereka jauh lebih mudah.

BLAS:

BLAS berevolusi dari level 1 (versi pertama yang mendefinisikan operasi skalar-vektor dan vektor-vektor) ke level 2 (operasi matriks-vektor) ke level 3 (operasi matriks-matriks), dan semakin banyak menyediakan "kernel" sehingga standar dan lebih banyak operasi aljabar linier mendasar. Implementasi FORTRAN 77 asli masih tersedia di situs web Netlib .

Menuju kinerja yang lebih baik:

Jadi selama bertahun-tahun (terutama antara rilis BLAS level 1 dan level 2: awal 80-an), perangkat keras berubah, dengan munculnya operasi vektor dan hierarki cache. Evolusi ini memungkinkan untuk meningkatkan kinerja subrutin BLAS secara substansial. Vendor yang berbeda kemudian datang dengan implementasi rutinitas BLAS mereka yang semakin efisien.

Saya tidak tahu semua implementasi historis (saya tidak dilahirkan atau masih kecil saat itu), tetapi dua yang paling menonjol keluar pada awal 2000-an: Intel MKL dan GotoBLAS. Matlab Anda menggunakan Intel MKL, yang merupakan BLAS yang sangat bagus, dioptimalkan, dan itu menjelaskan kinerja hebat yang Anda lihat.

Rincian teknis tentang perkalian Matriks:

Jadi mengapa Matlab (MKL) begitu cepat dgemm(multiplikasi matriks-matriks umum presisi ganda) Secara sederhana: karena menggunakan vektorisasi dan caching data yang baik. Dalam istilah yang lebih kompleks: lihat artikel yang disediakan oleh Jonathan Moore.

Pada dasarnya, ketika Anda melakukan perkalian dalam kode C ++ yang Anda berikan, Anda sama sekali tidak ramah terhadap cache. Karena saya curiga Anda membuat array pointer ke array baris, akses Anda di loop batin Anda ke kolom k-th "matice2": matice2[m][k]sangat lambat. Memang, ketika Anda mengakses matice2[0][k], Anda harus mendapatkan elemen k-th dari array 0 dari matriks Anda. Kemudian dalam iterasi berikutnya, Anda harus mengakses matice2[1][k], yang merupakan elemen k-th dari array lain (array 1). Kemudian di iterasi berikutnya Anda mengakses array lain, dan seterusnya ... Karena seluruh matriks matice2tidak dapat ditampung di cache tertinggi (ini 8*1024*1024byte besar), program harus mengambil elemen yang diinginkan dari memori utama, kehilangan banyak waktu.

Jika Anda baru saja memindahkan matriks, sehingga akses akan berada di alamat memori yang berdekatan, kode Anda akan berjalan jauh lebih cepat karena sekarang kompiler dapat memuat seluruh baris dalam cache pada saat yang sama. Coba saja versi modifikasi ini:

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

Jadi Anda dapat melihat bagaimana hanya cache lokalitas meningkatkan kinerja kode Anda secara substansial. Sekarang dgemmimplementasi nyata mengeksploitasi itu ke tingkat yang sangat luas: Mereka melakukan perkalian pada blok dari matriks yang didefinisikan oleh ukuran TLB (buffer lookaside terjemahan, cerita panjang pendek: apa yang secara efektif dapat di-cache), sehingga mereka mengalir ke prosesor persis jumlah data yang dapat diproses. Aspek lainnya adalah vektorisasi, mereka menggunakan instruksi yang di-vektor-kan prosesor untuk throughput instruksi yang optimal, yang tidak dapat Anda lakukan dari kode C ++ cross-platform Anda.

Akhirnya, orang mengklaim bahwa itu karena algoritma Strassen atau Coppersmith-Winograd salah, kedua algoritma ini tidak dapat diterapkan dalam praktik, karena pertimbangan perangkat keras yang disebutkan di atas.


2
Saya baru saja menonton video Scott Meyers tentang pentingnya ukuran cache dan pas data ke dalam ukuran garis cache, dan masalah yang dapat Anda miliki dengan solusi multi-threaded yang tidak memiliki data bersama di sumber tetapi berakhir dengan data yang dibagikan di perangkat keras / level inti-utas: youtu.be/WDIkqP4JbkE
WillC

40

Ini sebabnya . MATLAB tidak melakukan perkalian matriks naif dengan mengulangi setiap elemen seperti yang Anda lakukan pada kode C ++.

Tentu saja saya berasumsi bahwa Anda hanya menggunakan C=A*Balih-alih menulis fungsi perkalian sendiri.


19

Matlab memasukkan LAPACK beberapa waktu lalu, jadi saya menganggap perkalian matriks mereka menggunakan sesuatu yang setidaknya secepat itu. Kode sumber dan dokumentasi LAPACK sudah tersedia.

Anda juga dapat melihat makalah Goto dan Van De Geijn "Anatomi Pengganda Matriks Berkinerja Tinggi" di http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.140.1785&rep=rep1&type=pdf


7
MATLAB menggunakan Intel MKL Library yang menyediakan implementasi optimal dari rutinitas BLAS / LAPACK: stackoverflow.com/a/16723946/97160
Amro

11

Jawabannya adalah perpustakaan LAPACK dan BLAS membuat MATLAB sangat cepat di operasi matriks, bukan kode kepemilikan oleh orang-orang di MATLAB.

Gunakan perpustakaan LAPACK dan / atau BLAS dalam kode C ++ Anda untuk operasi matriks dan Anda harus mendapatkan kinerja yang sama seperti MATLAB. Perpustakaan-perpustakaan ini harus tersedia secara bebas di sistem modern apa pun dan bagian-bagiannya dikembangkan selama beberapa dekade di dunia akademis. Perhatikan bahwa ada beberapa implementasi, termasuk beberapa sumber tertutup seperti Intel MKL .

Diskusi tentang bagaimana BLAS mendapatkan kinerja tinggi tersedia di sini.


BTW, itu adalah rasa sakit yang serius dalam pengalaman saya untuk memanggil perpustakaan LAPACK langsung dari c (tapi layak). Anda perlu membaca dokumentasi SANGAT tepat.


8

Ketika melakukan perkalian matriks, Anda menggunakan metode perkalian naif yang membutuhkan waktu O(n^3).

Ada algoritma multiplikasi matriks yang dibutuhkan O(n^2.4). Yang berarti bahwa pada n=2000algoritma Anda membutuhkan ~ 100 kali lebih banyak perhitungan daripada algoritma terbaik.
Anda harus benar-benar memeriksa halaman wikipedia untuk perkalian matriks untuk informasi lebih lanjut tentang cara-cara efisien untuk mengimplementasikannya.


dan MATLAB mungkin menggunakan algoritma seperti itu karena waktu untuk 1024 * 1024 perkalian matriks lebih kecil dari 8 kali waktu untuk perkalian matriks 2048 * 2048! Baik dilakukan MATLAB guys.
Renaud

4
Saya agak ragu mereka menggunakan algoritma multiplikasi "efisien", terlepas dari keunggulan teoretis mereka. Algoritma bahkan Strassen memiliki kesulitan implementasi, dan algoritma Coppersmith-Winograd yang mungkin Anda baca tentang sekadar tidak praktis (sekarang). Juga, utas terkait SO: stackoverflow.com/questions/17716565/…
Ernir

Algoritma itu hanya untuk matriks yang sangat besar.

@Renaud. Itulah definisi overhead yang relatif konstan
Fisikawan Gila

6

Tergantung pada versi Matlab Anda, saya yakin itu mungkin sudah menggunakan GPU Anda.

Hal lain; Matlab melacak banyak properti dari matriks Anda; apakah diagonal, hermetian, dan sebagainya, dan mengkhususkan algoritmanya berdasarkan padanya. Mungkin itu mengkhususkan berdasarkan nol matriks yang Anda lewati, atau sesuatu seperti itu? Mungkin itu caching panggilan fungsi berulang, yang mengacaukan timing Anda? Mungkin itu mengoptimalkan produk matriks yang tidak digunakan berulang?

Untuk mencegah hal-hal seperti itu terjadi, gunakan matriks angka acak, dan pastikan Anda memaksakan eksekusi dengan mencetak hasilnya ke layar atau disk atau semacamnya.


4
Sebagai pengguna ML berat, saya dapat memberi tahu Anda mereka belum menggunakan GPGPU. Versi baru dari matlab DO menggunakan SSE1 / 2 (akhirnya). Tapi saya sudah melakukan tes. Sebuah MexFunction yang melakukan perkalian elemen-bijaksana berjalan dua kali lebih cepat dari biasanya A.*B. Jadi OP hampir pasti melakukan sesuatu.
KitsuneYMG

6
Matlab dengan Parallel Computing Toolbox dapat menggunakan GPU CUDA, tetapi eksplisit - Anda harus mendorong data ke GPU.
Edric

Saya menggunakan M1 = tunggal (rand (1024,1024) * 255); M2 = tunggal (rand (1024.1010) * 255); dan M3 = M1 * M2; ... kemudian menulis ke file biner mengapung, semuanya dilakukan dengan sangat cepat.
Wolf

3

MATLAB menggunakan implementasi LAPACK yang sangat optimal dari Intel yang dikenal sebagai Intel Math Kernel Library (Intel MKL) - khususnya fungsi dgemm . Kecepatan Perpustakaan ini memanfaatkan fitur prosesor termasuk instruksi SIMD dan prosesor multi-core. Mereka tidak mendokumentasikan algoritma spesifik apa yang mereka gunakan. Jika Anda memanggil Intel MKL dari C ++ Anda akan melihat kinerja yang sama.

Saya tidak yakin perpustakaan apa yang digunakan MATLAB untuk perkalian GPU tetapi mungkin sesuatu seperti nVidia CUBLAS .


1
Anda benar, tetapi apakah Anda sudah melihat jawaban ini ? Namun, IPP bukan MKL dan MKL memiliki kinerja aljabar linier yang jauh lebih unggul dibandingkan dengan IPP. Juga, IPP tidak lagi menggunakan modul matematika matriks dalam versi terbaru.
chappjc

Maaf saya maksudkan MKL bukan IPP
gregswiss

Anda benar jawaban yang lain menutupinya. Sangat verbose sehingga saya melewatkannya.
gregswiss

2

Jawaban umum untuk "Mengapa matlab lebih cepat dalam melakukan xxx daripada program lain" adalah matlab memiliki banyak fungsi bawaan yang dioptimalkan.

Program lain yang digunakan sering tidak memiliki fungsi-fungsi ini sehingga orang menerapkan solusi kreatif mereka sendiri, yang ternyata lebih lambat daripada kode yang dioptimalkan secara profesional.

Ini dapat ditafsirkan dalam dua cara:

1) Cara umum / teoretis: Matlab tidak jauh lebih cepat, Anda hanya melakukan tolok ukur yang salah

2) Cara realistis: Untuk hal ini Matlab lebih cepat dalam praktik karena bahasa seperti c ++ terlalu mudah digunakan dengan cara yang tidak efektif.


7
Dia membandingkan kecepatan MATLAB dengan kecepatan fungsi yang ditulisnya dalam dua menit. Saya dapat menulis fungsi yang lebih cepat dalam 10 menit, atau fungsi yang jauh lebih cepat dalam dua jam. Orang-orang MATLAB telah menghabiskan lebih dari dua jam untuk mempercepat perkalian matriks mereka.
gnasher729

2

Kontras yang tajam tidak hanya karena optimasi Matlab yang luar biasa (seperti yang sudah dibahas oleh banyak jawaban lain), tetapi juga dalam cara Anda merumuskan matriks sebagai objek.

Sepertinya Anda membuat matriks daftar daftar? Daftar daftar berisi pointer ke daftar yang kemudian mengandung elemen matriks Anda. Lokasi daftar yang ada ditetapkan secara sewenang-wenang. Ketika Anda mengulangi indeks pertama Anda (nomor baris?), Waktu akses memori sangat signifikan. Sebagai perbandingan, mengapa Anda tidak mencoba mengimplementasikan matriks sebagai daftar tunggal / vektor menggunakan metode berikut?

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

Dan

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

Algoritma multiplikasi yang sama harus digunakan sehingga jumlah kegagalan adalah sama. (n ^ 3 untuk matriks ukuran persegi n)

Saya meminta Anda untuk mengatur waktu agar hasilnya sebanding dengan yang Anda miliki sebelumnya (pada mesin yang sama). Dengan perbandingan, Anda akan menunjukkan dengan tepat seberapa signifikan waktu akses memori!


2

Ini lambat di C ++ karena Anda tidak menggunakan multithreading. Pada dasarnya, jika A = BC, di mana mereka semua matriks, baris pertama A dapat dihitung secara independen dari baris ke-2, dll. Jika A, B, dan C semuanya matriks n, n Anda dapat mempercepat perkalian dengan faktor n ^ 2, sebagai

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

Jika Anda menggunakan, katakanlah, Eigen [ http://eigen.tuxfamily.org/dox/GettingStarted.html ], multithreading built-in dan jumlah utas dapat disesuaikan.


2

Karena MATLAB adalah bahasa pemrograman pada awalnya dikembangkan untuk aljabar linear numerik (manipulasi matriks), yang memiliki perpustakaan khusus dikembangkan untuk perkalian matriks. Dan sekarang MATLAB juga dapat menggunakan GPU (Graphics processing unit) untuk tambahan ini.

Dan jika kami melihat hasil perhitungan Anda:

             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

maka kita dapat melihat bahwa tidak hanya MATLAB yang begitu cepat dalam perkalian matriks: CUDA C (bahasa pemrograman dari NVIDIA) memiliki beberapa hasil yang lebih baik daripada MATLAB. CUDA C juga memiliki perpustakaan yang khusus dikembangkan untuk perkalian matriks dan menggunakan GPU.

Sejarah singkat MATLAB

Cleve Moler, ketua departemen ilmu komputer di University of New Mexico, mulai mengembangkan MATLAB pada akhir 1970-an. Dia mendesainnya untuk memberi siswa akses ke LINPACK (perpustakaan perangkat lunak untuk melakukan aljabar linear numerik) dan EISPACK(Adalah perpustakaan perangkat lunak untuk perhitungan numerik aljabar linier) tanpa mereka harus belajar Fortran. Segera menyebar ke universitas lain dan menemukan audiens yang kuat dalam komunitas matematika terapan. Jack Little, seorang insinyur, terekspos terhadapnya selama kunjungan yang dilakukan Moler ke Universitas Stanford pada tahun 1983. Menyadari potensi komersialnya, ia bergabung dengan Moler dan Steve Bangert. Mereka menulis ulang MATLAB di C dan mendirikan MathWorks pada tahun 1984 untuk melanjutkan pengembangannya. Perpustakaan yang ditulis ulang ini dikenal sebagai JACKPAC. Pada tahun 2000, MATLAB ditulis ulang untuk menggunakan set perpustakaan yang lebih baru untuk manipulasi matriks, LAPACK (adalah perpustakaan perangkat lunak standar untuk aljabar linear numerik).

Sumber

Apa itu CUDA C

CUDA C juga menggunakan perpustakaan yang dikembangkan khusus untuk perkalian matriks seperti OpenGL (Open Graphics Library). Ini juga menggunakan GPU dan Direct3D (di MS Windows).

The Platform CUDA dirancang untuk bekerja dengan bahasa pemrograman seperti C, C ++, dan Fortran. Aksesibilitas ini memudahkan spesialis dalam pemrograman paralel untuk menggunakan sumber daya GPU, berbeda dengan API sebelumnya seperti Direct3D dan OpenGL , yang membutuhkan keterampilan tingkat lanjut dalam pemrograman grafis. Juga, CUDA mendukung kerangka kerja pemrograman seperti OpenACC dan OpenCL .

masukkan deskripsi gambar di sini

Contoh aliran pemrosesan CUDA:

  1. Menyalin data dari memori utama ke memori GPU
  2. CPU memulai kernel penghitungan GPU
  3. Inti CUDA GPU menjalankan kernel secara paralel
  4. Salin data yang dihasilkan dari memori GPU ke memori utama

Membandingkan Kecepatan Eksekusi CPU dan GPU

Kami menjalankan patokan di mana kami mengukur jumlah waktu yang diperlukan untuk menjalankan 50 langkah waktu untuk ukuran grid 64, 128, 512, 1024, dan 2048 pada Prosesor Intel Xeon X5650 dan kemudian menggunakan GPU NVIDIA Tesla C2050.

masukkan deskripsi gambar di sini

Untuk ukuran grid 2048, algoritme menunjukkan penurunan 7,5x dalam waktu komputasi dari lebih dari satu menit pada CPU menjadi kurang dari 10 detik pada GPU. Plot skala log menunjukkan bahwa CPU sebenarnya lebih cepat untuk ukuran kotak kecil. Namun seiring dengan perkembangan teknologi dan semakin matang, solusi GPU semakin mampu menangani masalah yang lebih kecil, tren yang kami harapkan akan terus berlanjut.

Sumber

Dari pengantar untuk Panduan Pemrograman CUDA C:

Didorong oleh permintaan pasar yang tak terpuaskan untuk grafis 3D berdefinisi tinggi real-time, Unit Prosesor Grafis atau GPU yang dapat diprogram telah berevolusi menjadi prosesor banyak inti yang paralel, multithreaded, dengan tenaga kuda komputasi yang luar biasa dan bandwidth memori yang sangat tinggi, seperti digambarkan oleh Figure 1dan Figure 2.

Gambar 1. Operasi Titik-Mengambang per Detik untuk CPU dan GPU

masukkan deskripsi gambar di sini

Gambar 2 . Memory Bandwidth untuk CPU dan GPU

masukkan deskripsi gambar di sini

Alasan di balik perbedaan dalam kemampuan floating-point antara CPU dan GPU adalah bahwa GPU khusus untuk komputasi intensif, komputasi yang sangat paralel - persis tentang rendering grafik - dan karena itu dirancang sedemikian rupa sehingga lebih banyak transistor dikhususkan untuk pemrosesan data daripada caching data dan kontrol aliran, seperti yang diilustrasikan secara skematis oleh Figure 3.

Gambar 3 . GPU Mencurahkan Lebih Banyak Transistor untuk Pemrosesan Data

masukkan deskripsi gambar di sini

Lebih khusus lagi, GPU sangat cocok untuk mengatasi masalah yang dapat dinyatakan sebagai perhitungan paralel data - program yang sama dijalankan pada banyak elemen data secara paralel - dengan intensitas aritmatika tinggi - rasio operasi aritmatika dengan operasi memori. Karena program yang sama dijalankan untuk setiap elemen data, ada persyaratan yang lebih rendah untuk kontrol aliran yang canggih, dan karena dijalankan pada banyak elemen data dan memiliki intensitas aritmatika yang tinggi, latensi akses memori dapat disembunyikan dengan perhitungan daripada cache data yang besar .

Pemrosesan data-paralel memetakan elemen data ke utas pemrosesan paralel. Banyak aplikasi yang memproses set data besar dapat menggunakan model pemrograman data-paralel untuk mempercepat perhitungan. Dalam rendering 3D, set besar piksel dan simpul dipetakan ke utas paralel. Demikian pula, aplikasi pemrosesan gambar dan media seperti pasca-pemrosesan gambar yang diberikan, pengodean dan pengodean video, penskalaan gambar, penglihatan stereo, dan pengenalan pola dapat memetakan blok dan piksel gambar ke untaian pemrosesan paralel. Pada kenyataannya, banyak algoritma di luar bidang rendering dan pemrosesan gambar dipercepat oleh pemrosesan paralel data, dari pemrosesan sinyal umum atau simulasi fisika hingga keuangan komputasi atau biologi komputasi.

Sumber

Bacaan lanjutan


Beberapa segi menarik

Saya telah menulis multiplikasi matriks C ++ yang secepat Matlab tetapi butuh perhatian. (Sebelum Matlab menggunakan GPU untuk ini).

Itasi dari jawaban ini .


2
Kutipan terakhir itu bukan "fakta", itu hanya omong kosong. Orang itu telah mendapatkan beberapa permintaan kode sejak dia mempostingnya. Tapi tidak ada kode yang terlihat.
Cris Luengo

1
Deskripsi Anda tentang seberapa cepat Anda dapat melakukan perhitungan pada GPU tidak menjawab pertanyaan sama sekali. Kita semua tahu bahwa 128 core kecil dapat melakukan lebih banyak pekerjaan yang sama dan monoton daripada 2 core besar. "Dan sekarang MATLAB juga dapat menggunakan GPU (unit pemrosesan Grafik) untuk ini juga." Ya, tetapi tidak secara default. Multiplikasi matriks normal masih menggunakan BLAS.
Cris Luengo

@ ChrisLuengo, oke, itu bukan fakta! Mungkin Anda sudah benar tentang "membual" nya - kita tidak tahu tentang itu dan kami juga tidak tahu mengapa dia tidak menjawab. Untuk komentar kedua: deskripsi perhitungan GPU menjawab pertanyaan karena untuk perkalian matriks dalam aljabar linier ia menggunakan operasi floating-point. Mungkin ini tidak bisa dimengerti oleh semua orang, tetapi saya pikir mereka harus memahami dasar-dasar ini. Dalam kasus lain mereka harus mempelajari dasar-dasar ini terlebih dahulu sebelum mereka membaca beberapa artikel tentang matriks. Dan jika orang lain akan menulis kepada saya tentang hal itu maka saya akan menambahkan detail ini. Terima kasih!
Bharata

@ ChrisLuengo, saya menulis kata "additionally". Artinya: bisa digunakan. Ini juga berarti bahwa perkalian matriks normal masih menggunakan pustaka perangkat lunak. Apakah Anda pikir saya harus mengubah posting saya agar lebih dimengerti? Terima kasih atas komentar Anda!
Bharata
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.